-
-## 设计理念
-
-MindSpore源于全产业的最佳实践，向数据科学家和算法工程师提供了统一的模型训练、推理和导出等接口，支持端、边、云等不同场景下的灵活部署，推动深度学习和科学计算等领域繁荣发展。
-
-MindSpore提供了动态图和静态图统一的编码方式，用户无需开发多套代码，仅变更一行代码便可切换动态图/静态图模式，从而拥有更轻松的开发调试及性能体验。
-
-此外，由于MindSpore统一了单机和分布式训练的编码方式，开发者无需编写复杂的分布式策略，在单机代码中添加少量代码即可实现分布式训练，大大降低了AI开发门槛。
-
-## 层次结构
-
-MindSpore向用户提供了3个不同层次的API，支撑用户进行网络构建、整图执行、子图执行以及单算子执行，从低到高分别为Low-Level Python API、Medium-Level Python API以及High-Level Python API。
-
-
-
-- Low-Level Python API
-
- 第一层为低阶API，主要包括张量定义、基础算子、自动微分等模块，用户可使用低阶API轻松实现张量操作和求导计算。
-
-- Medium-Level Python API
-
- 第二层为中阶API，其封装了低价API，提供网络层、优化器、损失函数等模块，用户可通过中阶API灵活构建神经网络和控制执行流程，快速实现模型算法逻辑。
-
-- High-Level Python API
-
- 第三层为高阶API，其在中阶API的基础上又提供了训练推理的管理、Callback、混合精度训练等高级接口，方便用户控制整网的执行流程和实现神经网络的训练及推理。
diff --git a/api/source_zh_cn/programming_guide/auto_augmentation.md b/api/source_zh_cn/programming_guide/auto_augmentation.md
deleted file mode 100644
index 57ec65060e666988f7e7d9fa6f7f783256374f33..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/programming_guide/auto_augmentation.md
+++ /dev/null
@@ -1,112 +0,0 @@
-# 自动数据增强
-
-
-
-- [自动数据增强](#自动数据增强)
- - [基于概率动态调整数据增强策略](#基于概率动态调整数据增强策略)
- - [基于训练结果信息动态调整数据增强策略](#基于训练结果信息动态调整数据增强策略)
-
-
-
-
-
-## 基于概率动态调整数据增强策略
-
-MindSpore提供一系列基于概率的数据增强的API，用户可以对各种图像操作进行随机选择、组合，使数据增强更灵活。
-
-- [`RandomApply(transforms, prob=0.5)`](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.transforms.html?highlight=randomapply#mindspore.dataset.transforms.c_transforms.RandomApply)
-以一定的概率指定`transforms`操作，即可能执行，也可以能不执行；`transform`可以是一个，也可以是一系列。
-
- ```python
-
- rand_apply_list = RandomApply([c_vision.RandomCrop(), c_vision.RandomColorAdjust()])
- ds = ds.map(operations=rand_apply_list)
-
- ```
-
- 按50%的概率来顺序执行`RandomCrop`和`RandomColorAdjust`操作,否则都不执行。
-
-- [`RandomChoice(transforms)`](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.transforms.html?highlight=randomchoice#mindspore.dataset.transforms.c_transforms.RandomChoice)
-从`transfrom`操作中随机选择一个执行。
-
- ```python
-
- rand_choice = RandomChoice([c_vision.CenterCrop(), c_vision.RandomCrop()])
- ds = ds.map(operations=rand_choice)
-
- ```
-
- 分别以50%概率来执行`CenterCrop`和`RandomCrop`操作。
-
-- [`RandomSelectSubpolicy(policy)`](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.transforms.vision.html?highlight=randomselectsubpolicy#mindspore.dataset.transforms.vision.c_transforms.RandomSelectSubpolicy)
-用户可以预置策略（Policy），每次随机选择一个子策略（SubPolicy）组合，同一子策略中由若干个顺序执行的图像增强操作组成，每个操作与两个参数关联：1） 执行操作的概率 2）执行操作的幅度；
-对于一个batch中的每张图像，随机选择子策略来变换图像。
-
- ```python
-
- policy = [
- [(c_vision.RandomRotation((45, 45)), 0.5), (c_vision.RandomVerticalFlip(), 1.0), (c_vision.RandomColorAdjust(), 0.8)],
- [(c_vision.RandomRotation((90, 90)), 1), (c_vision.RandomColorAdjust(), 0.2)]
- ]
- ds = ds.map(operations=c_vision.RandomSelectSubpolicy(policy), input_columns=["image"])
-
- ```
-
- 示例中包括2条子策略，其中子策略1中包含`RandomRotation`、`RandomVerticalFlip`、`RandomColorAdjust`3个操作，概率分别为0.5、1.0、0.8；子策略2中包含`RandomRotation`和`RandomColorAdjust`，概率分别为1.0、2.0。
-
-## 基于训练结果信息动态调整数据增强策略
-
-Mindspore的`sync_wait`接口支持按batch或epoch粒度来调整数据增强策略，实现训练过程中动态调整数据增强策略。
-`sync_wait`必须和`sync_update`配合使用实现数据pipeline上的同步回调。
-
-- [`sync_wait(condition_name, num_batch=1, callback=None)`](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.html?highlight=sync_wait#mindspore.dataset.ImageFolderDatasetV2.sync_wait)
-- [`sync_update(condition_name, num_batch=None, data=None)`](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.html?highlight=sync_update#mindspore.dataset.ImageFolderDatasetV2.sync_update)
-
-`sync_wait`将阻塞整个数据处理pipeline直到`sync_update`触发用户预先定义的`callback`函数。
-
-1. 用户预先定义class`Augment`，其中`preprocess`为`map`操作中的自定义数据增强函数，`update`为更新数据增强策略的回调函数。
-
- ```python
- import mindspore.dataset.transforms.vision.py_transforms as transforms
- import mindspore.dataset as de
- import numpy as np
-
- class Augment:
- def __init__(self):
- self.ep_num = 0
- self.step_num = 0
-
- def preprocess(self, input_):
- return (np.array((input_ + self.step_num ** self.ep_num - 1), ))
-
- def update(self, data):
- self.ep_num = data['ep_num']
- self.step_num = data['step_num']
-
- ```
-
-2. 数据处理pipeline先回调自定义的增强策略更新函数`auto_aug.update`，然后在`map`操作中按更新后的策略来执行`auto_aug.preprocess`中定义的数据增强。
-
- ```python
-
- arr = list(range(1, 4))
- ds = de.NumpySlicesDataset(arr, shuffle=False)
- aug = Augment()
- ds= ds.sync_wait(condition_name="policy", callback=aug.update)
- ds = ds.map(operations=[aug.preprocess])
-
- ```
-
-3. 在每个step调用`sync_update`进行数据增强策略的更新。
-
- ```python
- epochs = 5
- itr = ds.create_tuple_iterator(num_epochs=epochs)
- step_num = 0
- for ep_num in range(epochs):
- for data in itr:
- print("epcoh: {}, step:{}, data :{}".format(ep_num, step_num, data))
- step_num += 1
- ds.sync_update(condition_name="policy", data={'ep_num': ep_num, 'step_num': step_num})
-
- ```
diff --git a/api/source_zh_cn/programming_guide/cell.md b/api/source_zh_cn/programming_guide/cell.md
deleted file mode 100644
index 8570e80c0a9d38524dcd8e21bd196ab4ef1da9b1..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/programming_guide/cell.md
+++ /dev/null
@@ -1,290 +0,0 @@
-# cell模块概述
-
-
-
-- [cell模块概述](#cell模块概述)
- - [概念用途](#概念用途)
- - [关键成员函数](#关键成员函数)
- - [模型层](#模型层)
- - [损失函数](#损失函数)
- - [网络构造](#Cell构造自定义网络)
-
-
-
-## 概念用途
-
-MindSpose的Cell类是构建所有网络的基类，也是网络的基本单元。当用户需要自定义网络时，需要继承Cell类，并重写__init_方法和contruct方法。
-
-损失函数，优化器和模型层等本质上也属于网络结构，也需要继承Cell类才能实现功能，同样用户也可以根据业务需求自定义这部分内容。
-
-本节内容首先将会介绍Cell类的关键成员函数，然后介绍基于Cell实现的MindSpore内置损失函数，优化器和模型层及使用方法，最后通过实例介绍
-如何利用Cell类构建自定义网络。
-
-## 关键成员函数
-
-### construct方法
-
-Cell类重写了__call__方法，在cell类的实例被调用时，会执行contruct方法。网络结构在contruct方法里面定义。
-
-下面的样例中，我们构建了一个简单的网络。用例的网络结构为Conv2d->BatchNorm2d->ReLU->Flatten->Dense。
-在construct方法中，x为输入数据， out是经过网络的每层计算后得到的计算结果。
-
-```
-class Net(nn.Cell):
- def __init__(self):
- super(Net, self).__init__()
- self.conv = nn.Conv2d(3, 64, 3, has_bias=False, weight_init='normal')
- self.bn = nn.BatchNorm2d(64)
- self.relu = nn.ReLU()
- self.flatten = nn.Flatten()
- self.fc = nn.Dense(64 * 222 * 222, 3)
-
- def construct(self, x):
- x = self.conv(x)
- x = self.bn(x)
- x = self.relu(x)
- x = self.flatten(x)
- out = self.fc(x)
- return out
-```
-
-### parameters_dict
-
-parameters_dict方法识别出网络结构中所有的参数，返回一个以key为参数名，value为参数值的OrderedDict()。
-
-Cell类中返回参数的方法还有许多，例如get_parameters()，trainable_params()等， 具体使用方法可以参见MindSpore API手册。
-
-代码样例如下：
-
-```
-net = Net()
-result = net.parameters_dict()
-print(result.keys())
-print(result['conv.weight'])
-```
-
-样例中的Net()采用上文构造网络的用例，打印了网络中是所有参数的名字和conv.weight参数的结果。
-
-运行结果如下：
-```
-odict_keys(['conv.weight', 'bn.moving_mean', 'bn.moving_variance', 'bn.gamma', 'bn.beta', 'fc.weight', 'fc.bias'])
-Parameter (name=conv.weight, value=[[[[ 1.07402597e-02 7.70052336e-03 5.55867562e-03]
- [-3.21971579e-03 -3.75304517e-04 -8.73021083e-04]
-...
-[-1.81201510e-02 -1.31190736e-02 -4.27651079e-03]]]])
-```
-
-### cells_and_names
-
-cells_and_names方法是一个迭代器，返回网络中每个cell的名字和它的内容本身。
-
-用例简单实现了网络的cell获取与打印每个cell名字的功能，其中根据上文网络结构可知，存在五个cell分别是'conv'，'bn'，'relu'，'flatten'，'fc'。
-
-代码样例如下：
-```
-net = Net()
-names = []
-for m in net.cells_and_names():
- names.append(m[0]) if m[0] else None
-print(names)
-```
-
-运行结果：
-```
-['conv', 'bn', 'relu', 'flatten', 'fc']
-```
-## 模型层
-
-在讲述了Cell的使用方法后可知，MindSpore能够以Cell为基类构造网络结构。
-
-为了方便业界需求及用户使用方便，MindSpore框架内置了大量的模型层，用户可以通过接口直接调用。
-
-同样，用户也可以自定义模型，此内容在cell自定义构建中介绍。
-
-### 内置模型层
-
-MindSpore框架在nn的layer层内置了丰富的接口，主要内容如下：
-
-- 激活层：
-
- 激活层内置了大量的激活函数，在定义网络结构中经常使用。激活函数为网络加入了非线性运算，使得网络能够拟合效果更好。
-
- 主要接口有Softmax，Relu，Elu，Tanh，Sigmoid等。
-
-- 基础层：
-
- 基础层实现了网络中一些常用的基础结构，例如全连接层，Onehot编码，Dropout，平铺层等都在此部分实现。
-
- 主要接口有Dense，Flatten，Dropout，Norm，OneHot等。
-
-- 容器层：
-
- 容器层主要功能是实现一些存储多个cell的数据结构。
-
- 主要接口有SequentialCell，CellList等。
-
-- 卷积层：
-
- 卷积层提供了一些卷积计算的功能，如普通卷积，深度卷积和卷积转置等。
-
- 主要接口有Conv2d，Conv1d，Conv2dTranspose，DepthwiseConv2d，Conv1dTranspose等。
-
-- 池化层：
-
- 池化层提供了平均池化和最大池化等计算的功能。
-
- 主要接口有AvgPool2d，MaxPool2d，AvgPool1d。
-
-- 嵌入层：
-
- 嵌入层提供word embedding的计算功能，将输入的单词映射为稠密向量。
-
- 主要接口有：Embedding，EmbeddingLookup，EmbeddingLookUpSplitMode等。
-
-- 长短记忆循环层：
-
- 长短记忆循环层提供LSTM计算功能。其中LSTM内部会调用LSTMCell接口， LSTMCell是一个LSTM单元，
- 对一个LSTM层做运算，当涉及多LSTM网络层运算时，使用LSTM接口。
-
- 主要接口有：LSTM，LSTMCell。
-
-- 标准化层：
-
- 标准化层提供了一些标准化的方法，即通过线性变换等方式将数据转换成均值和标准差。
-
- 主要接口有：BatchNorm1d，BatchNorm2d，LayerNorm，GroupNorm，GlobalBatchNorm等。
-
-- 数学计算层：
-
- 数据计算层提供一些算子拼接而成的计算功能，例如数据生成和一些数学计算等。
-
- 主要接口有ReduceLogSumExp，Range，LinSpace，LGamma等。
-
-- 图片层：
-
- 图片计算层提供了一些矩阵计算相关的功能，将图片数据进行一些变换与计算。
-
- 主要接口有ImageGradients，SSIM，MSSSIM，PSNR，CentralCrop等。
-
-- 量化层：
-
- 量化是指将数据从float的形式转换成一段数据范围的int类型，所以量化层提供了一些数据量化的方法和模型层结构封装。
-
- 主要接口有Conv2dBnAct，DenseBnAct，Conv2dBnFoldQuant，LeakyReLUQuant等。
-
-### 应用实例
-
-MindSpore的模型层在mindspore.nn下，使用方法如下所示：
-
-```
-class Net(nn.Cell):
- def __init__(self):
- super(Net, self).__init__()
- self.conv = nn.Conv2d(3, 64, 3, has_bias=False, weight_init='normal')
- self.bn = nn.BatchNorm2d(64)
- self.relu = nn.ReLU()
- self.flatten = nn.Flatten()
- self.fc = nn.Dense(64 * 222 * 222, 3)
-
- def construct(self, x):
- x = self.conv(x)
- x = self.bn(x)
- x = self.relu(x)
- x = self.flatten(x)
- out = self.fc(x)
- return out
-```
-
-依然是上述网络构造的用例，从这个用例中可以看出，程序调用了Conv2d，BatchNorm2d，ReLU，Flatten和Dense模型层的接口。
-在Net初始化方法里面被定义，然后在construct方法里面真正运行，这些模型层接口有序的连接，形成一个可执行的网络。
-
-## 损失函数
-
-目前MindSpore主要支持的损失函数有L1Loss，MSELoss，SmoothL1Loss，SoftmaxCrossEntropyWithLogits，SoftmaxCrossEntropyExpand
-和CosineEmbeddingLoss。
-
-MindSpore的损失函数全部是Cell的子类实现，所以也支持用户自定义损失函数，其构造方法在cell自定义构建中进行介绍。
-
-### 内置损失函数
-
-- L1Loss：
-
- 计算两个输入数据的绝对值误差，用于回归模型。reduction参数默认值为mean，返回loss平均值结果，
-若reduction值为sum，返回loss累加结果，若reduction值为none，返回每个loss的结果。
-
-- MSELoss:
-
- 计算两个输入数据的平方误差，用于回归模型。reduction参数默认值为mean，返回loss平均值结果，
-若reduction值为sum，返回loss累加结果，若reduction值为none，返回每个loss的结果。
-
-- SmoothL1Loss：
-
- SmoothL1Loss为平滑L1损失函数，用于回归模型，阈值sigma默认参数为1。
-
-- SoftmaxCrossEntropyWithLogits：
-
- 交叉熵损失函数，用于分类模型。当标签数据不是one-hot编码形式时，需要输入参数sparse为True。reduction参数
- 与L1Loss一致。
-
-- SoftmaxCrossEntropyExpand：
-
- 交叉熵扩展损失函数，用于分类模型。当标签数据不是one-hot编码形式时，需要输入参数sparse为True。
-
-- CosineEmbeddingLoss：
-
- CosineEmbeddingLoss用于衡量两个输入相似程度，用于分类模型。margin默认为0.0，reduction参数与L1Loss一致
-
-### 应用实例
-
-MindSpore的损失函数全部在mindspore.nn下，使用方法如下所示：
-
-```
-import numpy as np
-import mindspore.nn as nn
-from mindspore import Tensor
-
-loss = nn.L1Loss()
-input_data = Tensor(np.array([[1, 2, 3], [2, 3, 4]]).astype(np.float32))
-target_data = Tensor(np.array([[0, 2, 5], [3, 1, 1]]).astype(np.float32))
-print(loss(input_data, target_data))
-```
-
-此用例构造了两个Tensor数据，利用nn.L1Loss()接口定义了L1Loss，将input_data和target_data传入loss,
-执行L1Loss的计算，结果为1.5。若loss = nn.L1Loss(reduction='sum')，则结果为9.0。
-若loss = nn.L1Loss(reduction='none')，结果为[[1. 0. 2.] [1. 2. 3.]]
-
-
-## Cell构造自定义网络
-
-无论是网络结构，还是前文提到的模型层，损失函数和优化器等，本质上都是一个Cell，因此都可以自定义实现。
-
-首先构造一个继承cell的子类，然后在__init__方法里面定义算子和模型层等，然后在construct方法里面构造网络结构。
-
-以lenet5网络为例，在__init__方法中定义了卷积层，池化层和全连接层等结构单元，然后在construct方法将定义的内容连接在一起，
-形成一个完整lenet5的网络结构。
-
-lenet5网络实现方式如下所示：
-```
-import mindspore.nn as nn
-
-class LeNet5(nn.Cell):
- def __init__(self):
- super(LeNet5, self).__init__()
- self.conv1 = nn.Conv2d(3, 6, 5, pad_mode="valid")
- self.conv2 = nn.Conv2d(6, 16, 5, pad_mode="valid")
- self.fc1 = nn.Dense(16 * 5 * 5, 120)
- self.fc2 = nn.Dense(120, 84)
- self.fc3 = nn.Dense(84, 3)
- self.relu = nn.ReLU()
- self.max_pool2d = nn.MaxPool2d(kernel_size=2)
- self.flatten = nn.Flatten()
-
- def construct(self, x):
- x = self.max_pool2d(self.relu(self.conv1(x)))
- x = self.max_pool2d(self.relu(self.conv2(x)))
- x = self.flatten(x)
- x = self.relu(self.fc1(x))
- x = self.relu(self.fc2(x))
- x = self.fc3(x)
- return x
-```
diff --git a/api/source_zh_cn/programming_guide/dataset_conversion.md b/api/source_zh_cn/programming_guide/dataset_conversion.md
deleted file mode 100644
index 59e68a061ff4a680539cd85a9b9973622b189ee5..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/programming_guide/dataset_conversion.md
+++ /dev/null
@@ -1,521 +0,0 @@
-# MindSpore数据格式转换
-
-
-
-- [MindSpore数据格式转换](#mindspore数据格式转换)
- - [概述](#概述)
- - [非标准数据集转换MindRecord](#非标准数据集转换mindrecord)
- - [CV类数据集](#cv类数据集)
- - [NLP类数据集](#nlp类数据集)
- - [常用数据集转换MindRecord](#常用数据集转换mindrecord)
- - [转换CIFAR-10数据集](#转换cifar-10数据集)
- - [转换CIFAR-100数据集](#转换cifar-100数据集)
- - [转换ImageNet数据集](#转换imagenet数据集)
- - [转换MNIST数据集](#转换mnist数据集)
- - [转换CSV数据集](#转换csv数据集)
- - [转换TFRecord数据集](#转换tfrecord数据集)
-
-
-
-
-
-## 概述
-
-用户可以将非标准的数据集和常见的经典数据集转换为MindSpore数据格式即MindRecord，从而方便地加载到MindSpore中进行训练。同时，MindSpore在部分场景做了性能优化，使用MindSpore数据格式可以获得更好的性能体验。
-
-## 非标准数据集转换MindRecord
-
-主要介绍如何将CV类数据和NLP类数据转换为MindRecord格式，并通过MindDataset实现MindRecoed格式文件的读取。
-
-### CV类数据集
-
- ```python
- """
- 示例说明：本示例主要介绍用户如何将自己的CV类数据集转换成MindRecoed格式，并使用MindDataset读取。
- 详细步骤：
- 1. 创建一个包含100条记录的MindRecord文件，其样本包含file_name（字符串）, label（整形）, data（二进制）三个字段；
- 2. 使用MindDataset读取MindRecord文件。
- """
-
- from io import BytesIO
- import os
- import mindspore.dataset as ds
- from mindspore.mindrecord import FileWriter
- import mindspore.dataset.transforms.vision.c_transforms as vision
- from PIL import Image
-
- ################################ 生成MindRecord文件 ################################
-
- mindrecord_filename = "test.mindrecord"
-
- # 如果存在MindRecord文件，则需要先删除
- if os.path.exists(mindrecord_filename):
- os.remove(mindrecord_filename)
- os.remove(mindrecord_filename + ".db")
-
- # 创建写对象，将会生成 mindrecord_filename 和 mindrecord_filename.db 两个文件
- writer = FileWriter(file_name=mindrecord_filename, shard_num=1)
-
- # 定义数据集Schema
- cv_schema = {"file_name": {"type": "string"}, "label": {"type": "int32"}, "data": {"type": "bytes"}}
- writer.add_schema(cv_schema, "it is a cv dataset")
-
- # [可选]定义索引字段，只能是标量字段
- writer.add_index(["file_name", "label"])
-
- # 按Schema方式组织训练数据，并将其写入MindRecord文件
- # 此处使用Image.new(...)模拟图片数据，真实场景可以使用io接口读取磁盘上的图像数据
- data = []
- for i in range(100): # 模拟数据集有100个样本
- i += 1
-
- sample = {}
- white_io = BytesIO()
- Image.new('RGB', (i*10, i*10), (255, 255, 255)).save(white_io, 'JPEG') # 图片大小可以不同
- image_bytes = white_io.getvalue()
- sample['file_name'] = str(i) + ".jpg" # 对应file_name字段
- sample['label'] = i # 对应label字段
- sample['data'] = white_io.getvalue() # 对应data字段
-
- data.append(sample)
- if i % 10 == 0: # 每10条样本做一次写操作
- writer.write_raw_data(data)
- data = []
-
- if data: # 写入可能剩余的数据
- writer.write_raw_data(data)
-
- writer.commit() # 关闭写入操作
-
- ################################ 读取MindRecord文件 ################################
-
- data_set = ds.MindDataset(dataset_file=mindrecord_filename) # 创建读取对象，默认开启shuffle
- decode_op = vision.Decode()
- data_set = data_set.map(input_columns=["data"], operations=decode_op, num_parallel_workers=2) # 解码data字段
- count = 0
- for item in data_set.create_dict_iterator(): # 循环读取MindRecord中所有数据
- print("sample: {}".format(item))
- count += 1
- print("Got {} samples".format(count))
- ```
-
-### NLP类数据集
-
-> 因为NLP类数据一般会经过预处理转换为字典序，此预处理过程不在本示例范围，该示例只演示转换后的字典序数据如何写入MindRecord。
-
- ```python
- """
- 示例说明：本示例主要介绍用户如何将自己的NLP类数据集转换成MindRecoed格式，并使用MindDataset读取。
- 详细步骤：
- 1. 创建一个包含100条记录的MindRecord文件，其样本包含八个字段，均为整形数组；
- 2. 使用MindDataset读取MindRecord文件。
- """
-
- import os
- import numpy as np
- import mindspore.dataset as ds
- from mindspore.mindrecord import FileWriter
-
- ################################ 生成MindRecord文件 ################################
-
- mindrecord_filename = "test.mindrecord"
-
- # 如果存在MindRecord文件，则需要先删除
- if os.path.exists(mindrecord_filename):
- os.remove(mindrecord_filename)
- os.remove(mindrecord_filename + ".db")
-
- # 创建写对象，将会生成 mindrecord_filename 和 mindrecord_filename.db 两个文件
- writer = FileWriter(file_name=mindrecord_filename, shard_num=1)
-
- # 定义数据集Schema，此处认为文本已经转为字典序
- nlp_schema = {"source_sos_ids": {"type": "int64", "shape": [-1]},
- "source_sos_mask": {"type": "int64", "shape": [-1]},
- "source_eos_ids": {"type": "int64", "shape": [-1]},
- "source_eos_mask": {"type": "int64", "shape": [-1]},
- "target_sos_ids": {"type": "int64", "shape": [-1]},
- "target_sos_mask": {"type": "int64", "shape": [-1]},
- "target_eos_ids": {"type": "int64", "shape": [-1]},
- "target_eos_mask": {"type": "int64", "shape": [-1]}}
- writer.add_schema(nlp_schema, "it is a preprocessed nlp dataset")
-
- # 按Schema方式组织训练数据，并将其写入MindRecord文件
- data = []
- for i in range(100): # 模拟数据集有100个样本
- i += 1
-
- # 组织训练数据
- sample = {"source_sos_ids": np.array([i, i+1, i+2, i+3, i+4], dtype=np.int64),
- "source_sos_mask": np.array([i*1, i*2, i*3, i*4, i*5, i*6, i*7], dtype=np.int64),
- "source_eos_ids": np.array([i+5, i+6, i+7, i+8, i+9, i+10], dtype=np.int64),
- "source_eos_mask": np.array([19, 20, 21, 22, 23, 24, 25, 26, 27], dtype=np.int64),
- "target_sos_ids": np.array([28, 29, 30, 31, 32], dtype=np.int64),
- "target_sos_mask": np.array([33, 34, 35, 36, 37, 38], dtype=np.int64),
- "target_eos_ids": np.array([39, 40, 41, 42, 43, 44, 45, 46, 47], dtype=np.int64),
- "target_eos_mask": np.array([48, 49, 50, 51], dtype=np.int64)}
-
- data.append(sample)
- if i % 10 == 0: # 每10条样本做一次写操作
- writer.write_raw_data(data)
- data = []
-
- if data: # 写入可能剩余的数据
- writer.write_raw_data(data)
-
- writer.commit() # 关闭写入操作
-
- ################################ 读取MindRecord文件 ################################
-
- data_set = ds.MindDataset(dataset_file=mindrecord_filename) # 创建读取对象，默认开启shuffle
- count = 0
- for item in data_set.create_dict_iterator(): # 循环读取MindRecord中所有数据
- print("sample: {}".format(item))
- count += 1
- print("Got {} samples".format(count))
- ```
-
-## 常用数据集转换MindRecord
-
-MindSpore提供转换常见数据集的工具类，能够将常见的经典数据集转换为MindRecord格式。常见数据集及其对应的工具类列表如下。
-
-| 数据集 | 格式转换工具类 |
-| -------- | ------------ |
-| CIFAR-10 | Cifar10ToMR |
-| CIFAR-100 | Cifar100ToMR |
-| ImageNet | ImageNetToMR |
-| MNIST | MnistToMR |
-| TFRecord | TFRecordToMR |
-| CSV File | CsvToMR |
-
-更多数据集转换的详细说明可参见[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.mindrecord.html)。
-
-### 转换CIFAR-10数据集
-
-用户可以通过`Cifar10ToMR`类，将CIFAR-10原始数据转换为MindRecord格式。
-
-1. 下载[CIFAR-10数据集](https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz)并解压，目录结构如下所示。
-
- ```
- └─cifar-10-batches-py
- ├─batches.meta
- ├─data_batch_1
- ├─data_batch_2
- ├─data_batch_3
- ├─data_batch_4
- ├─data_batch_5
- ├─readme.html
- └─test_batch
- ```
-
-2. 导入数据集转换工具类`Cifar10ToMR`。
-
- ```python
- from mindspore.mindrecord import Cifar10ToMR
- ```
-
-3. 创建`Cifar10ToMR`对象，调用`transform`接口，将CIFAR-10数据集转换为MindRecord格式。
-
- ```python
- CIFAR10_DIR = "./cifar10/cifar-10-batches-py"
- MINDRECORD_FILE = "./cifar10.mindrecord"
- cifar10_transformer = Cifar10ToMR(CIFAR10_DIR, MINDRECORD_FILE)
- cifar10_transformer.transform(['label'])
- ```
-
- **参数说明：**
- - `CIFAR10_DIR`：CIFAR-10数据集的文件夹路径。
- - `MINDRECORD_FILE`：输出的MindSpore数据格式文件路径。
-
-### 转换CIFAR-100数据集
-
-用户可以通过`Cifar100ToMR`类，将CIFAR-100原始数据转换为MindRecord格式。
-
-1. 准备好CIFAR-100数据集，将文件解压至指定的目录（示例中将数据集保存到`cifar100`目录），如下所示。
-
- ```
- % ll cifar100/cifar-100-python/
- meta
- test
- train
- ```
- > CIFAR-100数据集下载地址：
-
-MindSpore的nn模块是Python实现的模型组件，是对低阶API的封装，主要包括各种模型层、损失函数、优化器等。
-
-同时nn也提供了部分与Primitive算子同名的接口，主要作用是对Primitive算子进行进一步封装，为用户提供更友好的API。
-
-代码样例如下：
-```python
-import numpy as np
-from mindspore.common.tensor import Tensor
-import mindspore.nn as nn
-import mindspore
-
-net = nn.PSNR()
-img1 = Tensor(np.random.random((1,3,16,16)), mindspore.float32)
-img2 = Tensor(np.random.random((1,3,16,16)), mindspore.float32)
-output = net(img1, img2)
-print("output =", output)
-```
-
-输出如下：
-```
-output = [7.6338434]
-```
-
-各种模型层、损失函数、优化器等代码样例正在完善中。
diff --git a/api/source_zh_cn/programming_guide/operator.md b/api/source_zh_cn/programming_guide/operator.md
deleted file mode 100644
index a62e2250259863469be22349a058727d7b8e12dc..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/programming_guide/operator.md
+++ /dev/null
@@ -1,454 +0,0 @@
-# 算子组件
-
-算子组件指常用的算子及其操作，按功能大致可分为张量操作，网络操作，数组操作，图像操作，编码操作，调试操作，量化操作等七个模块。所有的算子在Ascend芯片或者CPU, GPU的支持情况，参见[这里](https://www.mindspore.cn/docs/zh-CN/master/operator_list.html "list")
-
-
-这七类算子操作的相互关系见下:
-
-
-
-- [算子组件](#算子组件)
- - [张量操作](#张量操作)
- - [标量运算](#标量运算)
- - [加法](#加法)
- - [Element-wise 除法](#element-wise-除法)
- - [Element-wise 乘](#element-wise-乘)
- - [三角函数](#求三角函数)
- - [向量运算](#向量运算)
- - [Concat](#concat-算子)
- - [Squeeze](#squeeze)
- - [Sparse2Dense](#求sparse2dense改变tensor维度使其变稠密)
- - [ScalarCast](#scalarcast)
- - [矩阵运算](#矩阵运算)
- - [矩阵乘法](#矩阵乘法)
- - [常见范数](#常见范数)
- - [广播机制](#广播机制)
- - [网络操作](#网络操作)
- - [特征提取](#特征提取)
- - [卷积操作](#卷积操作)
- - [卷积的反向传播操作](#卷积的反向传播算子操作)
- - [激活函数](#激活函数)
- - [LossFunction](#lossfunction)
- - [L1 Loss](#l1loss)
- - [优化算法](#优化算法)
- - [SGD](#sgd)
- - [数组操作](#数组操作)
- - [DType](#dtype)
- - [Cast](#cast)
- - [Shape](#shape)
- - [图像操作](#图像操作)
- - [编码运算](#编码运算)
- - [BoundingBoxEncode](#boundingboxencode)
- - [BoundingBoxDecode](#boundingboxdecode)
- - [IOU](#iou-计算)
- - [调试操作](#调试操作)
- - [Debug](#debug)
- - [HookBackward](#hookbackward)
- - [量化操作](#量化操作)
- - [MinMaxUpdatePerLayer](#minmaxupdateperlayer)
-
-
-
-
-
-## 张量操作
-
-
-主要包括张量的结构操作和张量的数学运算。
-张量结构操作诸如：张量创建，索引切片，维度变换，合并分割。
-张量数学运算主要有：标量运算，向量运算，矩阵运算。另外我们会介绍张量运算的广播机制。
-本篇我们介绍张量的数学运算。
-
-
-
-### 标量运算
-张量的数学运算符可以分为标量运算符、向量运算符、以及矩阵运算符。
-加减乘除乘方，以及三角函数，指数，对数等常见函数，逻辑比较运算符等都是标量运算符。
-标量运算符的特点是对张量实施逐元素运算。
-有些标量运算符对常用的数学运算符进行了重载。并且支持类似numpy的广播特性。
-
-举例说明:
-```python
-import numpy as np
-import mindspore # 导入mindspore包
-from mindspore import Tensor # 导入mindspore下的Tensor包
-import mindspore.ops.operations as P
-input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
-input_y = 3.0
-input_x**input_y
-```
-
-真实输入为：
-```python
-print(input_x)
-[ 1. 8. 64.]
-```
-
-真实输出为：
-```python
-print(input_x**input_y)
-[ 1. 8. 64.]
-```
-
-#### 加法
-```python
-input_x + input_y
-[4.0 5.0 7.0]
-```
-
-除普通加外，还有element-wise加法:
-```python
-net = NetAddN()
-input_x = Tensor(np.array([1, 2, 3]), mindspore.float32)
-input_y = Tensor(np.array([4, 5, 6]), mindspore.float32)
-net(input_x, input_y, input_x, input_y)[10.0, 14.0, 18.0]
-```
-
-#### Element-wise 除法
-```python
-input_x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
-input_y = Tensor(np.array([3.0, 2.0, 3.0]), mindspore.float32)
-div = P.Div()
-div(input_x, input_y)
-```
-
-求FloorDiv:
-```python
-input_x = Tensor(np.array([2, 4, -1]), mindspore.int32))
-input_y = Tensor(np.array([3, 3, 3]), mindspore.int32)
-floor_div = P.FloorDiv()
-floor_div(input_x, input_y)[0, 1, -1]
-```
-
-#### Element-wise 乘
-```python
-input_x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
-input_y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
-mul = P.Mul()
-mul(input_x, input_y)
-```
-
-真实输出:
-```python
-[4, 10, 18]
-```
-
-#### 求三角函数:
-```python
-acos = P.ACos()
-input_x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
-output = acos(input_x)
-```
-
-### 向量运算
-向量运算符只在一个特定轴上运算，将一个向量映射到一个标量或者另外一个向量。
-
-#### Concat 算子:
-```python
-data1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
-data2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
-op = P.Concat()
-output = op((data1, data2))
-```
-
-#### Squeeze
-```python
-input_tensor = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
-squeeze = P.Squeeze(2)
-output = squeeze(input_tensor)
-```
-
-#### 求Sparse2Dense(改变tensor维度使其变稠密):
-```python
-indices = Tensor([[0, 1], [1, 2]])
-values = Tensor([1, 2], dtype=ms.float32)
-dense_shape = (3, 4)
-out = P.SparseToDense()(indices, values, dense_shape)
-```
-
-#### ScalarCast:
-```python
-scalar_cast = P.ScalarCast()
-output = scalar_cast(255.0, mindspore.int32)
-```
-
-### 矩阵运算
-矩阵运算包括: 矩阵乘法，矩阵范数，矩阵行列式，矩阵求特征值，矩阵分解等运算。
-
-#### 矩阵乘法:
-```python
-input_x = Tensor(np.ones(shape=[1, 3]), mindspore.float32)
-input_y = Tensor(np.ones(shape=[3, 4]), mindspore.float32)
-matmul = P.MatMul()
-output = matmul(input_x, input_y)
-```
-
-#### 常见范数:
-
-```python
-input_x = Tensor(np.ones([128, 64, 32, 64]), mindspore.float32)
-scale = Tensor(np.ones([64]), mindspore.float32)
-bias = Tensor(np.ones([64]), mindspore.float32)
-mean = Tensor(np.ones([64]), mindspore.float32)
-variance = Tensor(np.ones([64]), mindspore.float32)
-batch_norm = P.BatchNorm()
-output = batch_norm(input_x, scale, bias, mean, variance)
-```
-
-#### 广播机制
-
-Broadcast 广播一个tensor到整个group
-举例说明:
-```python
-from mindspore import Tensor
-from mindspore.communication import init
-import mindspore.nn as nn
-import mindspore.ops.operations as P
-init()
-class Net(nn.Cell):
- def __init__(self):
- super(Net, self).__init__()
- self.broadcast = P.Broadcast(1)
-
- def construct(self, x):
- return self.broadcast((x,))
-
-input_ = Tensor(np.ones([2, 8]).astype(np.float32))
-net = Net()
-output = net(input_)
-```
-
-## 网络操作
-
-
-网络操作包括特征提取, 激活函数， LossFunction, 优化算法等：
-
-### 特征提取
-
-#### 卷积操作
-举例说明:
-```python
-input = Tensor(np.ones([10, 32, 32, 32]), mindspore.float32)
-weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32))
-conv2d = P.Conv2D(out_channel=32, kernel_size=3)
-conv2d(input, weight)
-```
-
-#### 卷积的反向传播算子操作：
-输出结果:
-```python
-dout = Tensor(np.ones([10, 32, 30, 30]), mindspore.float32)
-weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
-x = Tensor(np.ones([10, 32, 32, 32]))
-conv2d_backprop_input = P.Conv2DBackpropInput(out_channel=32, kernel_size=3)
-conv2d_backprop_input(dout, weight, F.shape(x))
-```
-
-### 激活函数
-举例说明:
-```python
-input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-softmax = P.Softmax()
-softmax(input_x)
-```
-
-输出结果:
-```python
-[0.01165623, 0.03168492, 0.08612854, 0.23412167, 0.6364086]
-```
-
-### LossFunction
-
-#### L1Loss:
-举例说明：
-```python
-loss = P.SmoothL1Loss()
-input_data = Tensor(np.array([1, 2, 3]), mindspore.float32)
-target_data = Tensor(np.array([1, 2, 2]), mindspore.float32)
-loss(input_data, target_data)
-```
-
-输出结果:
-```python
-[0, 0, 0.5]
-```
-
-### 优化算法
-#### SGD:
-```python
-sgd = P.SGD()
-parameters = Tensor(np.array([2, -0.5, 1.7, 4]), mindspore.float32)
-gradient = Tensor(np.array([1, -1, 0.5, 2]), mindspore.float32)
-learning_rate = Tensor(0.01, mindspore.float32)
-accum = Tensor(np.array([0.1, 0.3, -0.2, -0.1]), mindspore.float32)
-momentum = Tensor(0.1, mindspore.float32)
-stat = Tensor(np.array([1.5, -0.3, 0.2, -0.7]), mindspore.float32)
-result = sgd(parameters, gradient, learning_rate, accum, momentum, stat)
-```
-
-## 数组操作
-
-
-
-数组操作指操作对象是一些数组的操作。
-
-### DType
-返回跟输入的数据类型一致的并且适配Mindspore的tensor变量， 常用于Mindspore 工程内。
-举例说明:
-```python
-input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
-type = P.DType()(input_tensor)
-```
-
-### Cast
-转换输入的数据类型并且输出与目标数据类型相同的变量
-举例说明:
-```python
-input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
-input_x = Tensor(input_np)
-type_dst = mindspore.float16
-cast = P.Cast()
-result = cast(input_x, type_dst)
-```
-
-### Shape
-返回输入数据的形状
-举例说明:
-```python
-input_tensor = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
-shape = P.Shape()
-output = shape(input_tensor)
-```
-
-## 图像操作
-
-
-图像操作包括图像预处理操作， 如图像剪切（Crop，便于得到大量训练样本）和大小变化（Reise,用于构建图像金子塔等）：
-
-举例说明:
-```python
-class CropAndResizeNet(nn.Cell):
- def __init__(self, crop_size):
- super(CropAndResizeNet, self).__init__()
- self.crop_and_resize = P.CropAndResize()
- self.crop_size = crop_size
- @ms_function
- def construct(self, x, boxes, box_index):
- return self.crop_and_resize(x, boxes, box_index, self.crop_size)
-
-BATCH_SIZE = 1
-NUM_BOXES = 5
-IMAGE_HEIGHT = 256
-IMAGE_WIDTH = 256
-CHANNELS = 3
-image = np.random.normal(size=[BATCH_SIZE, IMAGE_HEIGHT, IMAGE_WIDTH, CHANNELS]).astype(np.float32)
-boxes = np.random.uniform(size=[NUM_BOXES, 4]).astype(np.float32)
-box_index = np.random.uniform(size=[NUM_BOXES], low=0, high=BATCH_SIZE).astype(np.int32)
-crop_size = (24, 24)
-crop_and_resize = CropAndResizeNet(crop_size=crop_size)
-output = crop_and_resize(Tensor(image), Tensor(boxes), Tensor(box_index))
-print(output.asnumpy())
-```
-
-## 编码运算
-
-
-编码运算包括 BoundingBox Encoding和 BoundingBox Decoding， IOU计算等。
-
-### BoundingBoxEncode
-对物体所在区域方框进行编码，得到类似PCA的更精简信息，以便做后续类似特征提取，物体检测，图像恢复等任务。
-
-举例说明:
-```python
-anchor_box = Tensor([[4,1,2,1],[2,2,2,3]],mindspore.float32)
-groundtruth_box = Tensor([[3,1,2,2],[1,2,1,4]],mindspore.float32)
-boundingbox_encode = P.BoundingBoxEncode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0))
-boundingbox_encode(anchor_box, groundtruth_box)
-```
-输出结果为:
-```python
-[[5.0000000e-01 5.0000000e-01 -6.5504000e+04 6.9335938e-01]
- [-1.0000000e+00 2.5000000e-01 0.0000000e+00 4.0551758e-01]]
-```
-
-### BoundingBoxDecode
-编码器对区域位置信息解码之后，用此算子进行解码。
-
-举例说明:
-```python
-anchor_box = Tensor([[4,1,2,1],[2,2,2,3]],mindspore.float32)
-deltas = Tensor([[3,1,2,2],[1,s2,1,4]],mindspore.float32)
-boundingbox_decode = P.BoundingBoxDecode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0), max_shape=(768, 1280), wh_ratio_clip=0.016)
-boundingbox_decode(anchor_box, deltas)
-```
-输出结果:
-```python
-[[4.1953125 0. 0. 5.1953125]
- [2.140625 0. 3.859375 60.59375]]
-```
-
-### IOU 计算：
-计算预测的物体所在方框和真实物体所在方框的交集区域与并集区域的占比大小。其常作为一种损失函数，用以优化模型。
-
-举例说明:
-```python
-iou = P.IOU()
-anchor_boxes = Tensor(np.random.randint(1.0, 5.0, [3, 4]), mindspore.float16)
-gt_boxes = Tensor(np.random.randint(1.0, 5.0, [3, 4]), mindspore.float16)
-```
-
-## 调试操作
-调试操作指的是用于调试网络的一些常用算子及其操作， 例如Debug等
-
-### Debug
-输出tensor变量的数值， 方便用户随时随地打印想了解或者debug必需的某变量数值。
-
-参考示例:
-```python
-class DebugNN(nn.Cell):
- def __init__(self,):
- self.debug = nn.Debug()
-
- def construct(self, x, y):
- x = self.add(x, y)
- self.debug(x)
- return x
-```
-
-### HookBackward
-打印中间变量的梯度，这一算子特别常用，遂举例在此，虽目前仅支持Pynative 形式
-参考示例:
-```python
-def hook_fn(grad_out):
- print(grad_out)
-
-grad_all = GradOperation(get_all=True)
-hook = P.HookBackward(hook_fn)
-
-def hook_test(x, y):
- z = x * y
- z = hook(z)
- z = z * y
- return z
-
-def backward(x, y):
- return grad_all(hook_test)(x, y)
-
-backward(1, 2)
-```
-
-## 量化操作
-
-
-量化操作指对tensor做量化或者反量化操作。 量化操作指将浮点数用整数的加和表示，利用整数加和并行加速时速度快的优点， 实
-现在可接受精度损失下的性能提升。反量化指其反过程，其在精度要求高的地方常被用到。
-
-### MinMaxUpdatePerLayer
-完成在训练时的量化和反量化操作
-举例说明:
-```python
-input_tensor = Tensor(np.random.rand(3, 16, 5, 5), mstype.float32)
-min_tensor = Tensor(np.array([-6]), mstype.float32)
-max_tensor = Tensor(np.array([6]), mstype.float32)
-output_tensor = FakeQuantPerLayer(num_bits=8)(input_tensor, min_tensor, max_tensor)
-```
diff --git a/api/source_zh_cn/programming_guide/ops.md b/api/source_zh_cn/programming_guide/ops.md
deleted file mode 100644
index 53bb69f5dfd011be5b4ed47d1f440da45df482a6..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/programming_guide/ops.md
+++ /dev/null
@@ -1,126 +0,0 @@
-# ops模块
-
-
-
-- [ops模块](#ops模块)
- - [mindspore.ops.operations](#mindsporeopsoperations)
- - [mindspore.ops.functional](#mindsporeopsfunctional)
- - [mindspore.ops.composite](#mindsporeopscomposite)
-
-
-
-
-
-MindSpore的ops模块主要存放算子相关接口，同时包含算子的校验和正反向关联的逻辑。
-
-ops主要包括operations、functional和composite，可通过ops直接获取到这三类算子。
-- operations提供单个的Primtive算子。一个算子对应一个原语，是最小的执行对象，需要实例化之后使用。
-- composite提供一些预定义的组合算子，以及复杂的涉及图变换的算子，如`GradOperation`。
-- functional提供operations和composite实例化后的对象，简化算子的调用流程。
-
-## mindspore.ops.operations
-
-operations提供了所有的Primitive算子接口，是开放给用户的最低阶算子接口。算子支持情况可查询[算子支持列表](https://www.mindspore.cn/docs/zh-CN/master/operator_list.html#mindspore-ops-operations)。
-
-Primitive算子也称为算子原语，它直接封装了底层的Ascend、GPU、AICPU、CPU等多种算子的具体实现，为用户提供基础算子能力。
-
-Primitive算子接口是构建高阶接口、自动微分、网络模型等能力的基础。
-
-代码样例如下：
-```python
-import numpy as np
-import mindspore
-from mindspore import Tensor
-import mindspore.ops.operations as P
-
-input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
-input_y = 3.0
-pow = P.Pow()
-output = pow(input_x, input_y)
-print("output =", output)
-```
-
-输出如下：
-```
-output = [ 1. 8. 64.]
-```
-
-## mindspore.ops.functional
-
-为了简化没有属性的算子的调用流程，MindSpore提供了一些算子的functional版本。入参要求参考原算子的输入输出要求。算子支持情况可以查询[算子支持列表](https://www.mindspore.cn/docs/zh-CN/master/operator_list.html#mindspore-ops-functional)。
-
-例如`P.Pow`算子，我们提供了functional版本的`F.tensor_pow`算子。
-
-使用functional的代码样例如下：
-
-```python
-import numpy as np
-import mindspore
-from mindspore import Tensor
-from mindspore.ops import functional as F
-
-input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
-input_y = 3.0
-output = F.tensor_pow(input_x, input_y)
-print("output =", output)
-```
-
-输出如下：
-```
-output = [ 1. 8. 64.]
-```
-
-## mindspore.ops.composite
-
-composite提供了一些算子的组合，包括clip_by_value和random相关的一些算子，以及涉及图变换的函数（`GradOperation`、`HyperMap`和`Map`等）。
-
-算子的组合可以直接像一般函数一样使用，例如使用`normal`生成一个随机分布：
-```python
-from mindspore.common import dtype as mstype
-from mindspore.ops import composite as C
-from mindspore import Tensor
-
-mean = Tensor(1.0, mstype.float32)
-stddev = Tensor(1.0, mstype.float32)
-output = C.normal((2, 3), mean, stddev, seed=5)
-print("ouput =", output)
-```
-输出如下：
-```
-output = [[2.4911082 0.7941146 1.3117087]
- [0.30582333 1.772938 1.525996]]
-```
-
-> 以上代码运行于MindSpore的GPU版本。
-
-针对涉及图变换的函数，用户可以使用`MultitypeFuncGraph`定义一组重载的函数，根据不同类型，走到不同实现。
-
-代码样例如下：
-```python
-import numpy as np
-from mindspore.ops.composite import MultitypeFuncGraph
-from mindspore import Tensor
-from mindspore.ops import functional as F
-
-add = MultitypeFuncGraph('add')
-@add.register("Number", "Number")
-def add_scalar(x, y):
- return F.scalar_add(x, y)
-
-@add.register("Tensor", "Tensor")
-def add_tensor(x, y):
- return F.tensor_add(x, y)
-
-tensor1 = Tensor(np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32'))
-tensor2 = Tensor(np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32'))
-print('tensor', add(tensor1, tensor2))
-print('scalar', add(1, 2))
-```
-输出如下：
-```
-tensor [[2.4, 4.2]
- [4.4, 6.4]]
-scalar 3
-```
-
-此外，高阶函数`GradOperation`提供了根据输入的函数，求这个函数对应的梯度函数的方式，详细可以参阅[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.composite.html#mindspore.ops.composite.GradOperation)。
\ No newline at end of file
diff --git a/api/source_zh_cn/programming_guide/security_and_privacy.md b/api/source_zh_cn/programming_guide/security_and_privacy.md
deleted file mode 100644
index 8b6d6c20c9846c8847f76851223ad04ba451fa14..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/programming_guide/security_and_privacy.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# AI安全与隐私保护
-
-
-
-- [AI安全与隐私保护](AI安全与隐私保护)
- - [概述](#概述)
- - [对抗鲁棒性](#对抗鲁棒性)
- - [Attack](#Attack)
- - [Defense](#Defense)
- - [Detector](#Detector)
- - [模型安全测试](#模型安全测试)
- - [Fuzzer](#Fuzzer)
- - [差分隐私训练](#差分隐私训练)
- - [DPModel](#DPModel)
- - [隐私泄露风险评估](#隐私泄露风险评估)
- - [MembershipInference](#MembershipInference)
-
-
-
-## 概述
-
-本篇是AI安全与隐私保护的编程指南。
-
-AI作为一种通用技术，在带来巨大机遇和效益的同时也面临着新的安全与隐私保护的挑战。MindArmour是MindSpore的一个子项目，为MindSpore提供安全与隐私保护能力，主要包括对抗鲁棒性、模型安全测试、差分隐私训练、隐私泄露风险评估等技术。
-
-## 对抗鲁棒性
-
-### Attack
-Attack基类定义了对抗样本生成的使用接口，其子类实现了各种具体的生成算法，支持安全工作人员快速高效地生成对抗样本，用于攻击AI模型，以评估模型的鲁棒性。
-
-### Defense
-Defense基类定义了对抗训练的使用接口，其子类实现了各种具体的对抗训练算法，增强模型的对抗鲁棒性。
-
-### Detector
-Detector基类定义了对抗样本检测的使用借口，其子类实现了各种具体的检测算法，增强模型的对抗鲁棒性。
-
-详细内容，请参考[对抗鲁棒性官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/model_security.html)
-
-## 模型安全测试
-
-### Fuzzer
-
-Fuzzer类基于神经元覆盖率增益控制fuzzing流程，采用自然扰动和对抗样本生成方法作为变异策略，激活更多的神经元，从而探索不同类型的模型输出结果、错误行为，指导用户增强模型鲁棒性。
-
-详细内容，请参考[模型安全测试官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/fuzzer.html)
-
-## 差分隐私训练
-
-### DPModel
-
-DPModel继承了mindspore.Model，提供了差分隐私训练的入口函数。
-
-详细内容，请参考[差分隐私官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/differential_privacy.html)
-
-## 隐私泄露风险评估
-
-### MembershipInference
-
-MembershipInference类提供了一种模型逆向分析方法，能够基于模型对样本的预测信息，推测某个样本是否在模型的训练集中，以此评估模型的隐私泄露风险。
-
-详细内容，请参考[隐私泄露风险评估官方教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/membership_inference.html)
diff --git a/api/source_zh_cn/programming_guide/type.md b/api/source_zh_cn/programming_guide/type.md
deleted file mode 100644
index 3ccdb560386cb1a9fa71fd8dc6e724f2ca135662..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/programming_guide/type.md
+++ /dev/null
@@ -1,54 +0,0 @@
-# 数据类型
-
-
-
-- [数据类型](#数据类型)
- - [概述](#概述)
- - [操作接口](#操作接口)
-
-
-
-
-
-
-## 概述
-
-MindSpore张量支持不同的数据类型，有`int8`、`int16`、`int32`、`int64`、`uint8`、`uint16`、`uint32`、`uint64`、
-`float16`、`float32`、`float64`、`bool_`， 与NumPy的数据类型一一对应，Python里的`int`数会被转换为定义的int64进行运算，
-Python里的`float`数会被转换为定义的`float32`进行运算。
-
-## 操作接口
-- `dtype_to_nptype`
-
- 可通过该接口将MindSpore的数据类型转换为NumPy对应的数据类型。
-
-- `dtype_to_pytype`
-
- 可通过该接口将MindSpore的数据类型转换为Python对应的内置数据类型。
-
-
-- `pytype_to_dtype`
-
- 可通过该接口将Python内置的数据类型转换为MindSpore对应的数据类型。
-
-示例如下：
-
-```
-from mindspore import dtype as mstype
-
-np_type = mstype.dtype_to_nptype(mstype.int32)
-ms_type = mstype.pytype_to_dtype(int)
-py_type = mstype.dtype_to_pytype(mstype.float64)
-
-print(np_type)
-print(ms_type)
-print(py_type)
-```
-
-输出如下：
-
-```
-
+
+Here is a list of all classes with links to the namespace documentation for each member:
+
+| Namespace | Class Name | Description |
+| --- | --- | --- |
+| mindspore::lite | [Allocator](https://www.mindspore.cn/doc/api_cpp/en/r1.0/lite.html#allocator) | Allocator defines a memory pool for dynamic memory malloc and memory free. |
+| mindspore::lite | [Context](https://www.mindspore.cn/doc/api_cpp/en/r1.0/lite.html#context) | Context defines for holding environment variables during runtime. |
+| mindspore::lite | [ModelImpl](https://www.mindspore.cn/doc/api_cpp/en/r1.0/lite.html#modelimpl) | ModelImpl defines the implement class of Model in MindSpore Lite. |
+| mindspore::lite | [PrimitiveC](https://www.mindspore.cn/doc/api_cpp/en/r1.0/lite.html#primitivec) | Primitive defines as prototype of operator. |
+| mindspore::lite | [Model](https://www.mindspore.cn/doc/api_cpp/en/r1.0/lite.html#model) | Model defines model in MindSpore Lite for managing graph. |
+| mindspore::lite | [ModelBuilder](https://www.mindspore.cn/doc/api_cpp/en/r1.0/lite.html#modelbuilder) | ModelBuilder is defined to build the model. |
+| mindspore::session | [LiteSession](https://www.mindspore.cn/doc/api_cpp/en/r1.0/session.html#litesession) | LiteSession defines session in MindSpore Lite for compiling Model and forwarding model. |
+| mindspore::tensor | [MSTensor](https://www.mindspore.cn/doc/api_cpp/en/r1.0/tensor.html#mstensor) | MSTensor defines tensor in MindSpore Lite. |
+| mindspore::dataset | [LiteMat](https://www.mindspore.cn/doc/api_cpp/en/r1.0/dataset.html#litemat) |Class that represents a LiteMat of a Image. |
diff --git a/docs/api_cpp/source_en/conf.py b/docs/api_cpp/source_en/conf.py
new file mode 100644
index 0000000000000000000000000000000000000000..4787de3f631f53db97bad94ffb7c95441edf0bb7
--- /dev/null
+++ b/docs/api_cpp/source_en/conf.py
@@ -0,0 +1,60 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+# import sys
+# sys.path.append('..')
+# sys.path.insert(0, os.path.abspath('.'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'MindSpore'
+copyright = '2020, MindSpore'
+author = 'MindSpore'
+
+# The full version, including alpha/beta/rc tags
+release = 'master'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+ 'sphinx_markdown_tables',
+ 'recommonmark',
+]
+
+source_suffix = {
+ '.rst': 'restructuredtext',
+ '.md': 'markdown',
+}
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+pygments_style = 'sphinx'
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages. See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_rtd_theme'
+
+html_static_path = ['_static']
\ No newline at end of file
diff --git a/lite/docs/source_en/apicc/dataset.md b/docs/api_cpp/source_en/dataset.md
similarity index 79%
rename from lite/docs/source_en/apicc/dataset.md
rename to docs/api_cpp/source_en/dataset.md
index 984ffc15eaa2fc44ed5e17c87f89b561083a5eae..0ee300ffdb93fa03142568936ed27411c6bf70e0 100644
--- a/lite/docs/source_en/apicc/dataset.md
+++ b/docs/api_cpp/source_en/dataset.md
@@ -1,12 +1,15 @@
# mindspore::dataset
-#include <[lite_mat.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.h)>
-#include <[image_process.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.h)>
+
+\#include <[lite_mat.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.h)>
+\#include <[image_process.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.h)>
-## Functions of image_process.h
+## Functions of image_process.h
-```
+### ResizeBilinear
+
+```cpp
bool ResizeBilinear(LiteMat &src, LiteMat &dst, int dst_w, int dst_h)
```
@@ -22,7 +25,9 @@ Resize image by bilinear algorithm, currently the data type only supports uint8,
Return True or False.
-```
+### InitFromPixel
+
+```cpp
bool InitFromPixel(const unsigned char *data, LPixelType pixel_type, LDataType data_type, int w, int h, LiteMat &m)
```
@@ -40,7 +45,9 @@ Initialize LiteMat from pixel, currently the conversion supports rbgaTorgb and r
Return True or False.
-```
+### ConvertTo
+
+```cpp
bool ConvertTo(LiteMat &src, LiteMat &dst, double scale = 1.0)
```
@@ -56,7 +63,9 @@ Convert the data type, currently it supports converting the data type from uint8
Return True or False.
-```
+### Crop
+
+```cpp
bool Crop(LiteMat &src, LiteMat &dst, int x, int y, int w, int h)
```
@@ -74,8 +83,10 @@ Crop image, the channel supports is 3 and 1.
Return True or False.
-```
-bool SubStractMeanNormalize(LiteMat &src, LiteMat &dst, const float *mean, float *norm)
+### SubStractMeanNormalize
+
+```cpp
+bool SubStractMeanNormalize(const LiteMat &src, LiteMat &dst, const std::vector
+
Description of error code and meta type supported in MindSpore Lite.
## ErrorCode
| Definition | Value | Description |
| --- | --- | --- |
-| RET_OK | 0 | No error occurs. |
-| RET_ERROR | -1 | Common error code. |
+| RET_OK | 0 | No error occurs. |
+| RET_ERROR | -1 | Common error code. |
| RET_NULL_PTR | -2 | NULL pointer returned. |
| RET_PARAM_INVALID | -3 | Invalid parameter. |
-| RET_NO_CHANGE | -4 | No change. |
-| RET_SUCCESS_EXIT | -5 | No error but exit. |
-| RET_MEMORY_FAILED | -6 | Fail to create memory. |
-| RET_OUT_OF_TENSOR_RANGE | -101 | Failed to check range. |
-| RET_INPUT_TENSOR_ERROR | -102 | Failed to check input tensor. |
-| RET_REENTRANT_ERROR | -103 | Exist executor running. |
-| RET_GRAPH_FILE_ERR | -201 | Failed to verify graph file. |
-| RET_NOT_FIND_OP | -301 | Failed to find operator. |
-| RET_INVALID_OP_NAME | -302 | Invalid operator name. |
-| RET_INVALID_OP_ATTR | -303 | Invalid operator attr. |
-| RET_OP_EXECUTE_FAILURE | -304 | Failed to execute the operator. |
-| RET_FORMAT_ERR | -401 | Failed to check the tensor format. |
-| RET_INFER_ERR | -501 | Failed to infer shape. |
-| RET_INFER_INVALID | -502 | Invalid infer shape before runtime. |
+| RET_NO_CHANGE | -4 | No change. |
+| RET_SUCCESS_EXIT | -5 | No error but exit. |
+| RET_MEMORY_FAILED | -6 | Fail to create memory. |
+| RET_NOT_SUPPORT | -7 | Fail to support. |
+| RET_OUT_OF_TENSOR_RANGE | -101 | Failed to check range. |
+| RET_INPUT_TENSOR_ERROR | -102 | Failed to check input tensor. |
+| RET_REENTRANT_ERROR | -103 | Exist executor running. |
+| RET_GRAPH_FILE_ERR | -201 | Failed to verify graph file. |
+| RET_NOT_FIND_OP | -301 | Failed to find operator. |
+| RET_INVALID_OP_NAME | -302 | Invalid operator name. |
+| RET_INVALID_OP_ATTR | -303 | Invalid operator attr. |
+| RET_OP_EXECUTE_FAILURE | -304 | Failed to execute the operator. |
+| RET_FORMAT_ERR | -401 | Failed to check the tensor format. |
+| RET_INFER_ERR | -501 | Failed to infer shape. |
+| RET_INFER_INVALID | -502 | Invalid infer shape before runtime. |
+| RET_INPUT_PARAM_INVALID | -601 | Invalid input param by user. |
+| RET_INPUT_PARAM_LACK | -602 | Lack input param by user. |
## MetaType
+
An **enum** type.
| Type Definition | Value | Description |
@@ -47,4 +53,3 @@ An **enum** type.
|kNumberTypeFloat32| 43 | Indicating a data type of float32. |
|kNumberTypeFloat64| 44 | Indicating a data type of float64.|
|kNumberTypeEnd| 45 | The end of number type. |
-
diff --git a/docs/source_en/index.rst b/docs/api_cpp/source_en/index.rst
similarity index 55%
rename from docs/source_en/index.rst
rename to docs/api_cpp/source_en/index.rst
index b998ceb9e7171ee985df6dad5a31ce4ef7528c5f..989bb4682382d8ff79d7d795485bb86d53c15fd7 100644
--- a/docs/source_en/index.rst
+++ b/docs/api_cpp/source_en/index.rst
@@ -3,20 +3,16 @@
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
-MindSpore Documentation
+MindSpore C++ API
=======================
.. toctree::
- :glob:
- :maxdepth: 1
+ :glob:
+ :maxdepth: 1
- design
- roadmap
- benchmark
- network_list
- operator_list
- constraints_on_network_construction
- glossary
- FAQ
- help_seeking_path
- community
+ class_list
+ lite
+ session
+ tensor
+ dataset
+ errorcode_and_metatype
\ No newline at end of file
diff --git a/lite/docs/source_en/apicc/lite.md b/docs/api_cpp/source_en/lite.md
similarity index 49%
rename from lite/docs/source_en/apicc/lite.md
rename to docs/api_cpp/source_en/lite.md
index 93bc93edf0d709c8d227723f921ea39f9a39f3b0..7c466d8c737d27e8911f7defb1de67083ba1a289 100644
--- a/lite/docs/source_en/apicc/lite.md
+++ b/docs/api_cpp/source_en/lite.md
@@ -1,11 +1,12 @@
# mindspore::lite
-#include <[context.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/context.h)>
+
-#include <[model.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/model.h)>
+\#include <[context.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/context.h)>
-#include <[version.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/version.h)>
+\#include <[model.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/model.h)>
+\#include <[version.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/version.h)>
## Allocator
@@ -15,159 +16,156 @@ Allocator defines a memory pool for dynamic memory malloc and memory free.
Context is defined for holding environment variables during runtime.
-**Constructors & Destructors**
+### Constructors & Destructors
-```
+```cpp
Context()
```
Constructor of MindSpore Lite Context using default value for parameters.
-```
-Context(int thread_num, std::shared_ptr
+\#include <[lite_session.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/lite_session.h)>
## LiteSession
LiteSession defines session in MindSpore Lite for compiling Model and forwarding model.
-**Constructors & Destructors**
+### Constructors & Destructors
-```
+```cpp
LiteSession()
```
+
Constructor of MindSpore Lite LiteSession using default value for parameters.
-```
+
+```cpp
~LiteSession()
```
+
Destructor of MindSpore Lite LiteSession.
-**Public Member Functions**
-```
+### Public Member Functions
+
+```cpp
virtual void BindThread(bool if_bind)
```
+
Attempt to bind or unbind threads in the thread pool to or from the specified cpu core.
- Parameters
- `if_bind`: Define whether to bind or unbind threads.
-```
+```cpp
virtual int CompileGraph(lite::Model *model)
```
-Compile MindSpore Lite model.
-> Note: CompileGraph should be called before RunGraph.
+Compile MindSpore Lite model.
+
+> CompileGraph should be called before RunGraph.
- Parameters
@@ -41,20 +48,22 @@ Compile MindSpore Lite model.
- Returns
- STATUS as an error code of compiling graph, STATUS is defined in [errorcode.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/errorcode.h).
+ STATUS as an error code of compiling graph, STATUS is defined in [errorcode.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/errorcode.h).
-```
+```cpp
virtual std::vector
+\#include <[ms_tensor.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/ms_tensor.h)>
## MSTensor
MSTensor defined tensor in MindSpore Lite.
-**Constructors & Destructors**
-```
+### Constructors & Destructors
+
+```cpp
MSTensor()
```
+
Constructor of MindSpore Lite MSTensor.
- Returns
Instance of MindSpore Lite MSTensor.
-
-```
+
+```cpp
virtual ~MSTensor()
```
Destructor of MindSpore Lite Model.
-**Public Member Functions**
+### Public Member Functions
-```
+```cpp
virtual TypeId data_type() const
```
+
Get data type of the MindSpore Lite MSTensor.
-> Note: TypeId is defined in [mindspore/mindspore/core/ir/dtype/type_id.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/core/ir/dtype/type_id.h). Only number types in TypeId enum are suitable for MSTensor.
+> TypeId is defined in [mindspore/mindspore/core/ir/dtype/type_id.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/core/ir/dtype/type_id.h). Only number types in TypeId enum are suitable for MSTensor.
- Returns
MindSpore Lite TypeId of the MindSpore Lite MSTensor.
-```
-virtual TypeId set_data_type(TypeId data_type)
-```
-Set data type for the MindSpore Lite MSTensor.
-
-- Parameters
-
- - `data_type`: Define MindSpore Lite TypeId to be set in the MindSpore Lite MSTensor.
-
-- Returns
-
- MindSpore Lite TypeId of the MindSpore Lite MSTensor after set.
-
-```
+```cpp
virtual std::vector
+
+MindSpore Lite中的类定义及其所属命名空间和描述：
+
+| 命名空间 | 类 | 描述 |
+| --- | --- | --- |
+| mindspore::lite | [Allocator](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#allocator) | Allocator定义了一个内存池，用于动态地分配和释放内存。 |
+| mindspore::lite | [Context](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#context) | Context用于保存执行期间的环境变量。 |
+| mindspore::lite | [ModelImpl](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#modelimpl) | ModelImpl定义了MindSpore Lite中的Model的实现类。 |
+| mindspore::lite | [PrimitiveC](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#primitivec) | PrimitiveC定义为算子的原型。 |
+| mindspore::lite | [Model](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#model) | Model定义了MindSpore Lite中的模型，便于计算图管理。 |
+| mindspore::lite | [ModelBuilder](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#modelbuilder) | ModelBuilder定义了MindSpore Lite中的模型构建器。 |
+| mindspore::session | [LiteSession](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/session.html#litesession) | LiteSession定义了MindSpore Lite中的会话，用于进行Model的编译和前向推理。 |
+| mindspore::tensor | [MSTensor](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/tensor.html#mstensor) | MSTensor定义了MindSpore Lite中的张量。 |
+| mindspore::dataset | [LiteMat](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/dataset.html#litemat) |LiteMat是一个处理图像的类。 |
diff --git a/docs/api_cpp/source_zh_cn/conf.py b/docs/api_cpp/source_zh_cn/conf.py
new file mode 100644
index 0000000000000000000000000000000000000000..625e5acd3bde751f170596e75261be4bb2bde60f
--- /dev/null
+++ b/docs/api_cpp/source_zh_cn/conf.py
@@ -0,0 +1,65 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+# import sys
+# sys.path.append('..')
+# sys.path.insert(0, os.path.abspath('.'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'MindSpore'
+copyright = '2020, MindSpore'
+author = 'MindSpore'
+
+# The full version, including alpha/beta/rc tags
+release = 'master'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+ 'sphinx_markdown_tables',
+ 'recommonmark',
+]
+
+source_suffix = {
+ '.rst': 'restructuredtext',
+ '.md': 'markdown',
+}
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+pygments_style = 'sphinx'
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages. See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_rtd_theme'
+
+html_search_language = 'zh'
+
+html_search_options = {'dict': '../../resource/jieba.txt'}
+
+html_static_path = ['_static']
\ No newline at end of file
diff --git a/lite/docs/source_zh_cn/apicc/dataset.md b/docs/api_cpp/source_zh_cn/dataset.md
similarity index 79%
rename from lite/docs/source_zh_cn/apicc/dataset.md
rename to docs/api_cpp/source_zh_cn/dataset.md
index 379d3e11632327b3075c0f8a56d53c852cdeae80..38b6dc30537c48d3881fe6d49f35b334c7e92ffa 100644
--- a/lite/docs/source_zh_cn/apicc/dataset.md
+++ b/docs/api_cpp/source_zh_cn/dataset.md
@@ -1,12 +1,15 @@
# mindspore::dataset
-#include <[lite_mat.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.h)>
-#include <[image_process.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.h)>
+
+\#include <[lite_mat.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/lite_mat.h)>
+\#include <[image_process.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.h)>
## image_process.h文件的函数
-```
+### ResizeBilinear
+
+```cpp
bool ResizeBilinear(LiteMat &src, LiteMat &dst, int dst_w, int dst_h)
```
@@ -22,7 +25,9 @@ bool ResizeBilinear(LiteMat &src, LiteMat &dst, int dst_w, int dst_h)
返回True或者False。
-```
+### InitFromPixel
+
+```cpp
bool InitFromPixel(const unsigned char *data, LPixelType pixel_type, LDataType data_type, int w, int h, LiteMat &m)
```
@@ -40,7 +45,9 @@ bool InitFromPixel(const unsigned char *data, LPixelType pixel_type, LDataType d
返回True或者False。
-```
+### ConvertTo
+
+```cpp
bool ConvertTo(LiteMat &src, LiteMat &dst, double scale = 1.0)
```
@@ -56,7 +63,9 @@ bool ConvertTo(LiteMat &src, LiteMat &dst, double scale = 1.0)
返回True或者False。
-```
+### Crop
+
+```cpp
bool Crop(LiteMat &src, LiteMat &dst, int x, int y, int w, int h)
```
@@ -74,8 +83,10 @@ bool Crop(LiteMat &src, LiteMat &dst, int x, int y, int w, int h)
返回True或者False。
-```
-bool SubStractMeanNormalize(LiteMat &src, LiteMat &dst, const float *mean, float *norm)
+### SubStractMeanNormalize
+
+```cpp
+bool SubStractMeanNormalize(const LiteMat &src, LiteMat &dst, const std::vector
+
以下表格描述了MindSpore Lite中支持的错误码和元类型。
## ErrorCode
@@ -13,6 +15,7 @@
| RET_NO_CHANGE | -4 | 无改变。 |
| RET_SUCCESS_EXIT | -5 | 无错误退出。 |
| RET_MEMORY_FAILED | -6 | 创建内存失败。 |
+| RET_NOT_SUPPORT | -7 | 尚未支持。 |
| RET_OUT_OF_TENSOR_RANGE | -101 | 输出检查越界。 |
| RET_INPUT_TENSOR_ERROR | -102 | 输入检查越界。 |
| RET_REENTRANT_ERROR | -103 | 存在运行中的执行器。 |
@@ -24,6 +27,8 @@
| RET_FORMAT_ERR | -401 | 张量格式检查失败。 |
| RET_INFER_ERR | -501 | 维度推理失败。 |
| RET_INFER_INVALID | -502 | 无效的维度推理。 |
+| RET_INPUT_PARAM_INVALID | -601 | 无效的用户输入参数。 |
+| RET_INPUT_PARAM_LACK | -602 | 缺少必要的输入参数。 |
## MetaType
@@ -48,4 +53,3 @@
|kNumberTypeFloat32| 43 | 表示Float32数据类型。 |
|kNumberTypeFloat64| 44 | 表示Float64数据类型。|
|kNumberTypeEnd| 45 | 表示Number类型的结尾。 |
-
diff --git a/lite/docs/source_en/index.rst b/docs/api_cpp/source_zh_cn/index.rst
similarity index 48%
rename from lite/docs/source_en/index.rst
rename to docs/api_cpp/source_zh_cn/index.rst
index abecfe957e16896bca6efeb5a1cb376835251fa6..989bb4682382d8ff79d7d795485bb86d53c15fd7 100644
--- a/lite/docs/source_en/index.rst
+++ b/docs/api_cpp/source_zh_cn/index.rst
@@ -1,16 +1,18 @@
.. MindSpore documentation master file, created by
- sphinx-quickstart on Thu Aug 17 10:00:00 2020.
+ sphinx-quickstart on Thu Mar 24 10:00:00 2020.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
-MindSpore Lite Documentation
-============================
+MindSpore C++ API
+=======================
.. toctree::
- :glob:
- :maxdepth: 1
+ :glob:
+ :maxdepth: 1
- architecture
- apicc/apicc
- operator_list
- glossary
+ class_list
+ lite
+ session
+ tensor
+ dataset
+ errorcode_and_metatype
\ No newline at end of file
diff --git a/lite/docs/source_zh_cn/apicc/lite.md b/docs/api_cpp/source_zh_cn/lite.md
similarity index 41%
rename from lite/docs/source_zh_cn/apicc/lite.md
rename to docs/api_cpp/source_zh_cn/lite.md
index 2673487a861f56db5c8b9f6bab8daac555cb7fed..4dcbaeeb39bf57f66af0d16fc66843e54e6c3b33 100644
--- a/lite/docs/source_zh_cn/apicc/lite.md
+++ b/docs/api_cpp/source_zh_cn/lite.md
@@ -1,197 +1,173 @@
-# mindspore::lite
-
-#include <[context.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/context.h)>
-
-#include <[model.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/model.h)>
-
-#include <[version.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/version.h)>
-
-
-## Allocator
-
-Allocator类定义了一个内存池，用于动态地分配和释放内存。
-
-## Context
-
-Context类用于保存执行中的环境变量。
-
-**构造函数和析构函数**
-
-```
-Context()
-```
-
-用默认参数构造MindSpore Lite Context 对象。
-
-```
-Context(int thread_num, std::shared_ptr
+
+\#include <[context.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/context.h)>
+
+\#include <[model.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/model.h)>
+
+\#include <[version.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/version.h)>
+
+## Allocator
+
+Allocator类定义了一个内存池，用于动态地分配和释放内存。
+
+## Context
+
+Context类用于保存执行中的环境变量。
+
+### 构造函数和析构函数
+
+```cpp
+Context()
+```
+
+用默认参数构造MindSpore Lite Context 对象。
+
+```cpp
+~Context()
+```
+
+MindSpore Lite Context 的析构函数。
+
+### 公有属性
+
+```cpp
+float16_priority
+```
+
+**bool**值，默认为**false**，用于使能float16 推理。
+
+> 使能float16推理可能会导致模型推理精度下降，因为在模型推理的中间过程中，有些变量可能会超出float16的数值范围。
+
+```cpp
+device_type
+```
+
+[**DeviceType**](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#devicetype)枚举类型。默认为**DT_CPU**，用于设置设备信息。
+
+```cpp
+thread_num_
+```
+
+**int** 值，默认为**2**，设置线程数。
+
+```cpp
+allocator
+```
+
+指针类型，指向内存分配器[**Allocator**](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#allocator)的指针。
+
+```cpp
+cpu_bind_mode_
+```
+
+[**CpuBindMode**](https://www.mindspore.cn/doc/api_cpp/zh-CN/r1.0/lite.html#cpubindmode)枚举类型，默认为**MID_CPU**。
+
+## PrimitiveC
+
+PrimitiveC定义为算子的原型。
+
+## Model
+
+Model定义了MindSpore Lite中的模型，便于计算图管理。
+
+### 析构函数
+
+```cpp
+~Model()
+```
+
+MindSpore Lite Model的析构函数。
+
+### 公有成员函数
+
+```cpp
+void Destroy()
+```
+
+释放Model内的所有过程中动态分配的内存。
+
+```cpp
+void Free()
+```
+
+释放MindSpore Lite Model中的MetaGraph，用于减小运行时的内存。
+
+### 静态公有成员函数
+
+```cpp
+static Model *Import(const char *model_buf, size_t size)
+```
+
+创建Model指针的静态方法。
+
+- 参数
+
+ - `model_buf`: 定义了读取模型文件的缓存区。
+
+ - `size`: 定义了模型缓存区的字节数。
+
+- 返回值
+
+ 指向MindSpore Lite的Model的指针。
+
+## CpuBindMode
+
+枚举类型，设置cpu绑定策略。
+
+### 属性
+
+```cpp
+MID_CPU = -1
+```
+
+优先中等CPU绑定策略。
+
+```cpp
+HIGHER_CPU = 1
+```
+
+优先高级CPU绑定策略。
+
+```cpp
+NO_BIND = 0
+```
+
+不绑定。
+
+## DeviceType
+
+枚举类型，设置设备类型。
+
+### 属性
+
+```cpp
+DT_CPU = -1
+```
+
+设备为CPU。
+
+```cpp
+DT_GPU = 1
+```
+
+设备为GPU。
+
+```cpp
+DT_NPU = 0
+```
+
+设备为NPU，暂不支持。
+
+## Version
+
+```cpp
+std::string Version()
+```
+
+全局方法，用于获取版本的字符串。
+
+- 返回值
+
+ MindSpore Lite版本的字符串。
diff --git a/lite/docs/source_zh_cn/apicc/session.md b/docs/api_cpp/source_zh_cn/session.md
similarity index 71%
rename from lite/docs/source_zh_cn/apicc/session.md
rename to docs/api_cpp/source_zh_cn/session.md
index 86556e1351e97bf4ad435e09db907fdca4e5fefd..66b35e37a1c41539cff39f35d0da0295e82115bf 100644
--- a/lite/docs/source_zh_cn/apicc/session.md
+++ b/docs/api_cpp/source_zh_cn/session.md
@@ -1,177 +1,196 @@
-# mindspore::session
-
-#include <[lite_session.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/lite_session.h)>
-
-
-## LiteSession
-
-LiteSession定义了MindSpore Lite中的会话，用于进行Model的编译和前向推理。
-
-**构造函数和析构函数**
-
-```
-LiteSession()
-```
-MindSpore Lite LiteSession的构造函数，使用默认参数。
-```
-~LiteSession()
-```
-MindSpore Lite LiteSession的析构函数。
-
-**公有成员函数**
-```
-virtual void BindThread(bool if_bind)
-```
-尝试将线程池中的线程绑定到指定的cpu内核，或从指定的cpu内核进行解绑。
-
-- 参数
-
- - `if_bind`: 定义了对线程进行绑定或解绑。
-
-```
-virtual int CompileGraph(lite::Model *model)
-```
-编译MindSpore Lite模型。
-
-> 注意： CompileGraph必须在RunGraph方法之后调用。
-
-- 参数
-
- - `model`: 定义了需要被编译的模型。
-
-- 返回值
-
- STATUS ，即编译图的错误码。STATUS在[errorcode.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/lite/include/errorcode.h)中定义。
-
-```
-virtual std::vector
+
+\#include <[lite_session.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/lite_session.h)>
+
+## LiteSession
+
+LiteSession定义了MindSpore Lite中的会话，用于进行Model的编译和前向推理。
+
+### 构造函数和析构函数
+
+```cpp
+LiteSession()
+```
+
+MindSpore Lite LiteSession的构造函数，使用默认参数。
+
+```cpp
+~LiteSession()
+```
+
+MindSpore Lite LiteSession的析构函数。
+
+### 公有成员函数
+
+```cpp
+virtual void BindThread(bool if_bind)
+```
+
+尝试将线程池中的线程绑定到指定的cpu内核，或从指定的cpu内核进行解绑。
+
+- 参数
+
+ - `if_bind`: 定义了对线程进行绑定或解绑。
+
+```cpp
+virtual int CompileGraph(lite::Model *model)
+```
+
+编译MindSpore Lite模型。
+
+> CompileGraph必须在RunGraph方法之前调用。
+
+- 参数
+
+ - `model`: 定义了需要被编译的模型。
+
+- 返回值
+
+ STATUS ，即编译图的错误码。STATUS在[errorcode.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/errorcode.h)中定义。
+
+```cpp
+virtual std::vector
+\#include <[ms_tensor.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/lite/include/ms_tensor.h)>
## MSTensor
MSTensor定义了MindSpore Lite中的张量。
-**构造函数和析构函数**
-```
+## 构造函数和析构函数
+
+```cpp
MSTensor()
```
+
MindSpore Lite MSTensor的构造函数。
- 返回值
- MindSpore Lite MSTensor 的实例。
-
-```
+ MindSpore Lite MSTensor的实例。
+
+```cpp
virtual ~MSTensor()
```
+
MindSpore Lite Model的析构函数。
-**公有成员函数**
+### 公有成员函数
-```
+```cpp
virtual TypeId data_type() const
```
+
获取MindSpore Lite MSTensor的数据类型。
-> 注意：TypeId在[mindspore/mindspore/core/ir/dtype/type_id\.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/core/ir/dtype/type_id.h)中定义。只有TypeId枚举中的数字类型可用于MSTensor。
+> TypeId在[mindspore/mindspore/core/ir/dtype/type_id\.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/core/ir/dtype/type_id.h)中定义。只有TypeId枚举中的数字类型可用于MSTensor。
- 返回值
MindSpore Lite MSTensor类的MindSpore Lite TypeId。
-```
-virtual TypeId set_data_type(TypeId data_type)
-```
-设置MindSpore Lite MSTensor的数据类型。
-
-- 参数
-
- - `data_type`: 定义了MindSpore Lite MSTensor所需设置的MindSpore Lite TypeId。
-
-- 返回值
-
- 设置后的MindSpore Lite MSTensor的MindSpore Lite TypeI。
-
-```
+```cpp
virtual std::vector
+
+**Q: What can I do if the network performance is abnormal and weight initialization takes a long time during training after MindSpore is installed?**
+
+A: The `SciPy 1.4` series versions may be used in the environment. Run the `pip list | grep scipy` command to view the `SciPy` version and change the `SciPy` version to that required by MindSpore. You can view the third-party library dependency in the `requirement.txt` file.
+
+
+## Installing Using pip
+
+**Q: What can I do if an error message `cannot open shared object file:file such file or directory` is displayed when I install MindSpore of the GPU, CUDA 10.1, 0.5.0-beta, or Ubuntu-x86 version?**
+
+A: The error message indicates that the cuBLAS library is not found. Generally, the cause is that the cuBLAS library is not installed or is not added to the environment variable. Generally, cuBLAS is installed together with CUDA and the driver. After the installation, add the directory where cuBLAS is located to the `LD_LIBRARY_PATH` environment variable.
+
+
+
+**Q: What can I do if the error message `ImportError: libcrypto.so.1.0.0: cannot open shared object file: No such file or directory` is displayed in the MindInsight running logs after MindInsight failed to start?**
+
+A: You can use "export LD_LIBRARY_PATH=dir:$LD_LIBRARY_PATH" command to export LD_LIBRARY_PATH variable in Linux environment.
+
+
+
+**Q: After a model is trained, how do I save the model output in text or `npy` format?**
+
+A: The network output is `Tensor`. You need to use the `asnumpy()` method to convert the `Tensor` to `NumPy` and then save the data. For details, see the following:
+
+```python
+out = net(x)
+
+np.save("output.npy", out.asnumpy())
+```
+
+
+
+**Q: Does MindSpore run only on Huawei `NPUs`?**
+
+A: MindSpore supports Huawei Ascend `NPUs`, `GPUs`, and `CPUs`, and supports heterogeneous computing.
+
+
+
+**Q: The recent announced programming language such as taichi got Python extensions that could be directly used as `import taichi as ti`. Does MindSpore have similar support?**
+
+A: MindSpore supports Python native expression via `import mindspore`。
+
+
+
+**Q: How do I change hyperparameters for calculating loss values during neural network training?**
+
+A: Sorry, this function is not available yet. You can find the optimal hyperparameters by training, redefining an optimizer, and then training.
+
+
+
+**Q: Why is data loading abnormal when MindSpore1.0.1 is used in graph data offload mode?**
+
+A: An operator with the `axis` attribute, for example, `P.Concat(axis=1)((x1, x2))`, is directly used in `construct`. You are advised to initialize the operator in `__init__` as follows:
+
+```python
+from mindspore import nn
+from mindspore.ops import operations as P
+
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.concat = P.Concat(axis=1)
+ def construct(self, x, y):
+ out = self.concat((x, y))
+ return out
+```
+
+
+
+**Q：MindSpore安装完成，执行训练时发现网络性能异常，权重初始化耗时过长，怎么办？**
+
+A：可能与环境中使用了`scipy 1.4`系列版本有关，通过`pip list | grep scipy`命令可查看scipy版本，建议改成MindSpore要求的`scipy`版本。版本第三方库依赖可以在`requirement.txt`中查看。
+
+
+## pip安装
+
+**Q：安装MindSpore版本：GPU、CUDA 10.1、0.5.0-beta、Ubuntu-x86，出现问题：`cannot open shared object file:file such file or directory`。**
+
+A：从报错情况来看，是cublas库没有找到。一般的情况下是cublas库没有安装，或者是因为没有加入到环境变量中去。通常cublas是随着cuda以及驱动一起安装的，确认安装后把cublas所在的目录加入`LD_LIBRARY_PATH`环境变量中即可。
+
+
+
+**Q：MindInsight启动失败并且提示:`ImportError: libcrypto.so.1.0.0: cannnot open shared object file: No such file or directory` 如何处理？**
+
+A：需要在命令行中使用”export LD_LIBRARY_PATH=dir:$LD_LIBRARY_PATH”来导入LD_LIBRARY_PATH变量。
+
+
+
+**Q：模型已经训练好，如何将模型的输出结果保存为文本或者`npy`的格式？**
+
+A：您好，我们网络的输出为`Tensor`，需要使用`asnumpy()`方法将`Tensor`转换为`numpy`，再进行下一步保存。具体可参考：
+
+```python
+out = net(x)
+
+np.save("output.npy", out.asnumpy())
+```
+
+
+
+**Q:MindSpore只能在华为自己的`NPU`上跑么？**
+
+A: MindSpore同时支持华为自己的`Ascend NPU`、`GPU`与`CPU`，是支持异构算力的。
+
+
+
+**Q：最近出来的taichi编程语言有Python扩展，类似`import taichi as ti`就能直接用了，MindSpore是否也支持？**
+
+A：MindSpore支持Python原生表达，`import mindspore`相关包即可使用。
+
+
+
+**Q：如何在训练神经网络过程中对计算损失的超参数进行改变？**
+
+A：您好，很抱歉暂时还未有这样的功能。目前只能通过训练-->重新定义优化器-->训练，这样的过程寻找较优的超参数。
+
+
+
+**Q：使用MindSpore-1.0.1版本在图数据下沉模式加载数据异常是什么原因？**
+
+A：应该是`construct`中直接使用了带有`axis`属性的算子，比如`P.Concat(axis=1)((x1, x2))`这种，建议把算子在`__init__`中初始化 像这样
+
+```python
+from mindspore import nn
+from mindspore.ops import operations as P
+
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.concat = P.Concat(axis=1)
+ def construct(self, x, y):
+ out = self.concat((x, y))
+ return out
+```
+
+
+
This document describes the MindSpore benchmarks.
-For details about the MindSpore networks, see [Model Zoo](https://gitee.com/mindspore/mindspore/tree/master/model_zoo).
+For details about the MindSpore networks, see [Model Zoo](https://gitee.com/mindspore/mindspore/tree/r1.0/model_zoo).
## Training Performance
@@ -49,7 +49,7 @@ For details about the MindSpore networks, see [Model Zoo](https://gitee.com/mind
| | | | | Ascend: 8 * Ascend 910 CPU：192 Cores | Mixed | 16000*8 | 4872849 samples/sec | 0.76 |
1. The preceding performance is obtained based on Atlas 800, and the model is data parallel.
-2. For details about other open source frameworks, see [Wide & Deep For TensorFlow](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/Recommendation/WideAndDeep)。
+2. For details about other open source frameworks, see [Wide & Deep For TensorFlow](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/Recommendation/WideAndDeep).
### Wide & Deep (Host-Device model parallel)
@@ -61,4 +61,4 @@ For details about the MindSpore networks, see [Model Zoo](https://gitee.com/mind
| | | | | Ascend: 32 * Ascend 910 CPU：768 Cores | Mixed | 8000*32 | 433423 samples/sec | 0.20 |
1. The preceding performance is obtained based on Atlas 800, and the model is model parallel.
-2. For details about other open source frameworks, see [Wide & Deep For TensorFlow](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/Recommendation/WideAndDeep)。
+2. For details about other open source frameworks, see [Wide & Deep For TensorFlow](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/Recommendation/WideAndDeep).
diff --git a/docs/source_en/community.rst b/docs/note/source_en/community.rst
similarity index 80%
rename from docs/source_en/community.rst
rename to docs/note/source_en/community.rst
index 80c0ddf710394273e53eff9db6a1495d4a613a17..4609dee2bb085a96ce268ef1ad9f870b865ca6d2 100644
--- a/docs/source_en/community.rst
+++ b/docs/note/source_en/community.rst
@@ -1,5 +1,5 @@
-Community
-=========
+Participating in MindSpore Community
+====================================
Contributing Code
-----------------
diff --git a/lite/docs/source_en/conf.py b/docs/note/source_en/conf.py
similarity index 93%
rename from lite/docs/source_en/conf.py
rename to docs/note/source_en/conf.py
index fd89055b9bf9e2a889d23de6fa7395072650db42..a1fd767271ac159540440ed65bd0d676163366a9 100644
--- a/lite/docs/source_en/conf.py
+++ b/docs/note/source_en/conf.py
@@ -15,9 +15,9 @@ import os
# -- Project information -----------------------------------------------------
-project = 'MindSpore Lite'
-copyright = '2020, MindSpore Lite'
-author = 'MindSpore Lite'
+project = 'MindSpore'
+copyright = '2020, MindSpore'
+author = 'MindSpore'
# The full version, including alpha/beta/rc tags
release = 'master'
@@ -48,8 +48,6 @@ exclude_patterns = []
pygments_style = 'sphinx'
-autodoc_inherit_docstrings = False
-
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
diff --git a/docs/source_en/constraints_on_network_construction.md b/docs/note/source_en/constraints_on_network_construction.md
similarity index 70%
rename from docs/source_en/constraints_on_network_construction.md
rename to docs/note/source_en/constraints_on_network_construction.md
index 2da31582ec511af4c51e499d81e350b0b4d91797..9086c60ed39886de95e9443fc892ec6d808d0ccc 100644
--- a/docs/source_en/constraints_on_network_construction.md
+++ b/docs/note/source_en/constraints_on_network_construction.md
@@ -5,27 +5,27 @@
- [Constraints on Network Construction Using Python](#constraints-on-network-construction-using-python)
- - [Overview](#overview)
- - [Syntax Constraints](#syntax-constraints)
- - [Supported Python Data Types](#supported-python-data-types)
- - [MindSpore Extended Data Type](#mindspore-extended-data-type)
- - [Expression Types](#expression-types)
- - [Statement Types](#statement-types)
- - [System Functions/Class](#system-functionsclasses)
- - [Function Parameters](#function-parameters)
- - [Operators](#operators)
- - [Index operation](#index-operation)
- - [Unsupported Syntax](#unsupported-syntax)
- - [Network Definition Constraints](#network-definition-constraints)
- - [Instance Types on the Entire Network](#instance-types-on-the-entire-network)
- - [Network Input Type](#network-input-type)
- - [Network Graph Optimization](#network-graph-optimization)
- - [Network Construction Components](#network-construction-components)
- - [Other Constraints](#other-constraints)
+ - [Overview](#overview)
+ - [Syntax Constraints](#syntax-constraints)
+ - [Supported Python Data Types](#supported-python-data-types)
+ - [MindSpore Extended Data Type](#mindspore-extended-data-type)
+ - [Expression Types](#expression-types)
+ - [Statement Types](#statement-types)
+ - [System Functions/Classes](#system-functionsclasses)
+ - [Function Parameters](#function-parameters)
+ - [Operators](#operators)
+ - [Index operation](#index-operation)
+ - [Unsupported Syntax](#unsupported-syntax)
+ - [Network Definition Constraints](#network-definition-constraints)
+ - [Instance Types on the Entire Network](#instance-types-on-the-entire-network)
+ - [Network Input Type](#network-input-type)
+ - [Network Graph Optimization](#network-graph-optimization)
+ - [Network Construction Components](#network-construction-components)
+ - [Other Constraints](#other-constraints)
-
+
## Overview
MindSpore can compile user source code based on the Python syntax into computational graphs, and can convert common functions or instances inherited from nn.Cell into computational graphs. Currently, MindSpore does not support conversion of any Python source code into computational graphs. Therefore, there are constraints on source code compilation, including syntax constraints and network definition constraints. As MindSpore evolves, the constraints may change.
@@ -208,8 +208,8 @@ Currently, the following syntax is not supported in network constructors:
## Network Definition Constraints
### Instance Types on the Entire Network
-* Common Python function with the [@ms_function](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.html#mindspore.ms_function) decorator.
-* Cell subclass inherited from [nn.Cell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Cell).
+* Common Python function with the [@ms_function](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.html#mindspore.ms_function) decorator.
+* Cell subclass inherited from [nn.Cell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Cell).
### Network Input Type
* The training data input parameters of the entire network must be of the Tensor type.
@@ -222,44 +222,71 @@ Currently, the following syntax is not supported in network constructors:
| Category | Content
| :----------- |:--------
-| `Cell` instance |[mindspore/nn/*](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html), and custom [Cell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Cell).
+| `Cell` instance |[mindspore/nn/*](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html), and custom [Cell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Cell).
| Member function of a `Cell` instance | Member functions of other classes in the construct function of Cell can be called.
| Function | Custom Python functions and system functions listed in the preceding content.
| Dataclass instance | Class decorated with @dataclass.
-| Primitive operator |[mindspore/ops/operations/*](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html).
-| Composite operator |[mindspore/ops/composite/*](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.composite.html).
-| Operator generated by constexpr |Uses the value generated by [@constexpr](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.html#mindspore.ops.constexpr) to calculate operators.
+| Primitive operator |[mindspore/ops/operations/*](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html).
+| Composite operator |[mindspore/ops/composite/*](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html).
+| Operator generated by constexpr |Uses the value generated by [@constexpr](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.constexpr) to calculate operators.
### Other Constraints
-Input parameters of the construct function on the entire network and parameters of functions modified by the ms_function decorator are generalized during the graph compilation. Therefore, they cannot be transferred to operators as constant input. Therefore, in graph mode, the parameter passed to the entry network can only be Tensor. As shown in the following example:
-* The following is an example of incorrect input:
- ```python
- class ExpandDimsTest(Cell):
- def __init__(self):
- super(ExpandDimsTest, self).__init__()
- self.expandDims = P.ExpandDims()
-
- def construct(self, input_x, input_axis):
- return self.expandDims(input_x, input_axis)
- expand_dim = ExpandDimsTest()
- input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
- expand_dim(input_x, 0)
- ```
- In the example, ExpandDimsTest is a single-operator network with two inputs: input_x and input_axis. The second input of the ExpandDims operator must be a constant. This is because input_axis is required when the output dimension of the ExpandDims operator is deduced during graph compilation. As the network parameter input, the value of input_axis is generalized into a variable and cannot be determined. As a result, the output dimension of the operator cannot be deduced, causing the graph compilation failure. Therefore, the input required by deduction in the graph compilation phase must be a constant. In APIs, the "constant input is needed" is marked for parameters that require constant input of these operators.
+1. Input parameters of the `construct` function on the entire network and parameters of functions modified by the `ms_function` decorator are generalized during the graph compilation and cannot be passed to operators as constant input. Therefore, in graph mode, the parameter passed to the entry network can only be `Tensor`. As shown in the following example:
+
+ * The following is an example of incorrect input:
+ ```python
+ class ExpandDimsTest(Cell):
+ def __init__(self):
+ super(ExpandDimsTest, self).__init__()
+ self.expandDims = ops.ExpandDims()
+
+ def construct(self, input_x, input_axis):
+ return self.expandDims(input_x, input_axis)
+ expand_dim = ExpandDimsTest()
+ input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
+ expand_dim(input_x, 0)
+ ```
+ In the example, `ExpandDimsTest` is a single-operator network with two inputs: `input_x` and `input_axis`. The second input of the `ExpandDims` operator must be a constant. This is because `input_axis` is required when the output dimension of the `ExpandDims` operator is deduced during graph compilation. As the network parameter input, the value of `input_axis` is generalized into a variable and cannot be determined. As a result, the output dimension of the operator cannot be deduced, causing the graph compilation failure. Therefore, the input required by deduction in the graph compilation phase must be a constant. In the API, the parameters of this type of operator that require constant input will be explained, marked `const input is needed`.
+
+ * Directly enter the needed value or a member variable in a class for the constant input of the operator in the construct function. The following is an example of correct input:
+ ```python
+ class ExpandDimsTest(Cell):
+ def __init__(self, axis):
+ super(ExpandDimsTest, self).__init__()
+ self.expandDims = ops.ExpandDims()
+ self.axis = axis
+
+ def construct(self, input_x):
+ return self.expandDims(input_x, self.axis)
+ axis = 0
+ expand_dim = ExpandDimsTest(axis)
+ input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
+ expand_dim(input_x)
+ ```
+
+2. It is not allowed to modify `non-Parameter` type data members of the network. Examples are as follows:
-* Directly enter the needed value or a member variable in a class for the constant input of the operator in the construct function. The following is an example of correct input:
- ```python
- class ExpandDimsTest(Cell):
- def __init__(self, axis):
- super(ExpandDimsTest, self).__init__()
- self.expandDims = P.ExpandDims()
- self.axis = axis
-
- def construct(self, input_x):
- return self.expandDims(input_x, self.axis)
- axis = 0
- expand_dim = ExpandDimsTest(axis)
- input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
- expand_dim(input_x)
```
+ class Net(Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.num = 2
+ self.par = Parameter(Tensor(np.ones((2, 3, 4))), name="par")
+
+ def construct(self, x, y):
+ return x + y
+ ```
+ In the network defined above, `self.num` is not a `Parameter` and cannot be modified, but `self.par` is a `Parameter` and can be modified.
+
+3. When an undefined class member is used in the `construct` function, it will be treated as `None` instead of throwing `AttributeError` like the Python interpreter. Examples are as follows:
+
+ ```
+ class Net(Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+
+ def construct(self, x):
+ return x + self.y
+ ```
+ In the network defined above, the undefined class member `self.y` is used in `construct`, and `self.y` will be treated as `None`.
\ No newline at end of file
diff --git a/docs/note/source_en/design/mindarmour.rst b/docs/note/source_en/design/mindarmour.rst
new file mode 100644
index 0000000000000000000000000000000000000000..bfc20cfc28aab28e816fb3d976535139f731f0a8
--- /dev/null
+++ b/docs/note/source_en/design/mindarmour.rst
@@ -0,0 +1,8 @@
+MindArmour Design
+==================
+
+.. toctree::
+ :maxdepth: 1
+
+ mindarmour/differential_privacy_design
+ mindarmour/fuzzer_design
\ No newline at end of file
diff --git a/docs/note/source_en/design/mindarmour/differential_privacy_design.md b/docs/note/source_en/design/mindarmour/differential_privacy_design.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca85f78779a66e68f329afef9b2505f5248606bd
--- /dev/null
+++ b/docs/note/source_en/design/mindarmour/differential_privacy_design.md
@@ -0,0 +1,71 @@
+# Differential Privacy
+
+`Ascend` `Model Development` `Model Optimization` `Framework Development` `Enterprise` `Expert` `Contributor`
+
+
+
+- [Differential Privacy](#differential-privacy)
+ - [Overall Design](#overall-design)
+ - [DP Optimizer](#dp-optimizer)
+ - [DP Mechanisms](#dp-mechanisms)
+ - [Monitor](#monitor)
+ - [Code Implementation](#code-implementation)
+ - [References](#references)
+
+
+
+
+
+## Overall Design
+
+The Differential-Privacy module of MindArmour implements the differential privacy training capability. Model training consists of building training dataset, computing loss, computing gradient, and updating model parameters. Currently, the differential privacy training of MindArmour focuses on the gradient computing process and uses the corresponding algorithm to clip and add noise to the gradient. In this way, user data privacy is protected.
+
+
+
+
+
+## Background
+
+Different from [fuzzing security test for traditional programs](https://zhuanlan.zhihu.com/p/43432370), MindArmour provides the AI model security test module fuzz_testing for deep neural network. Based on the neural network features, the concept of neuron coverage rate [1] is introduced to guide the fuzz testing. Fuzz testing is guided to generate samples in the direction of increasing neuron coverage rate so that more neurons can be activated by inputs. The distribution range of neuron values is wider to fully test DNN and explore the output results of different types of models and model error behavior.
+
+## Fuzz Testing Design
+
+The following figure shows the security test design of the AI model.
+
+
+
+At the user interface layer, users need to provide the original dataset `DataSet`, tested model `Model`, and Fuzzer parameter `Fuzzer configuration`. After fuzzing the model and data, Fuzzer module returns the security report `Security Report`.
+
+Fuzz testting architecture consists of three modules:
+
+1. Natural Threat/Adversarial Example Generator:
+
+ Randomly select a mutation method to mutate seed data and generate multiple variants. Mutation policies supporting multiple samples include:
+
+ - Image affine transformation methods: Translate, Rotate, Scale, and Shear.
+ - Methods based on image pixel value changes: Contrast, Brightness, Blur, and Noise.
+ - Methods for generating adversarial examples based on white-box and black-box attacks: FGSM, PGD, and MDIIM.
+
+2. Fuzzer Moduler:
+
+ Perform fuzz testing on the mutated data to observe the change of the neuron coverage rate. If the generated data increases the neuron coverage rate, add the data to the mutated seed queue for the next round of data mutation. Currently, the following neuron coverage metrics are supported: KMNC, NBC, and SNAC [2].
+
+3. Evaluation:
+
+ Evaluate the fuzz testing effect, quality of generated data, and strength of mutation methods. Five metrics of three types are supported, including the general evaluation metric (accuracy), neuron coverage rate metrics (kmnc, nbc, and snac), and adversarial attack evaluation metric (attack_success_rate).
+
+## Fuzz Testing Process
+
+
+
+The fuzz testing process is as follows:
+
+1. Select seed A from the seed queue according to the policy.
+2. Randomly select a mutation policy to mutate seed A and generate multiple variants A1, A2, ...
+3. Use the target model to predict the variants. If the semantics of variant is consistent with the seed, the variant enters the Fuzzed Tests.
+4. If the prediction is correct, use the neuron coverage metric for analysis.
+5. If a variant increases the coverage rate, place the variant in the seed queue for the next round of mutation.
+
+Through multiple rounds of mutations, you can obtain a series of variant data in the Fuzzed Tests, perform further analysis, and provide security reports from multiple perspectives. You can use them to deeply analyze defects of the neural network model and enhance the model to improve its universality and robustness.
+
+## Code Implementation
+
+1. [fuzzing.py](https://gitee.com/mindspore/mindarmour/blob/r1.0/mindarmour/fuzz_testing/fuzzing.py): overall fuzz testing process.
+2. [model_coverage_metrics.py](https://gitee.com/mindspore/mindarmour/blob/r1.0/mindarmour/fuzz_testing/model_coverage_metrics.py): neuron coverage rate metrics, including KMNC, NBC, and SNAC.
+3. [image_transform.py](https://gitee.com/mindspore/mindarmour/blob/r1.0/mindarmour/fuzz_testing/image_transform.py): image mutation methods, including methods based on image pixel value changes and affine transformation methods.
+4. [adversarial attacks](https://gitee.com/mindspore/mindarmour/tree/r1.0/mindarmour/adv_robustness/attacks): methods for generating adversarial examples based on white-box and black-box attacks.
+
+## References
+
+[1] Pei K, Cao Y, Yang J, et al. Deepxplore: Automated whitebox testing of deep learning systems[C]//Proceedings of the 26th Symposium on Operating Systems Principles. ACM, 2017: 1-18.
+
+[2] Ma L, Juefei-Xu F, Zhang F, et al. Deepgauge: Multi-granularity testing criteria for deep learning systems[C]//Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering. ACM, 2018: 120-131.
\ No newline at end of file
diff --git a/docs/note/source_en/design/mindarmour/images/dp_arch.png b/docs/note/source_en/design/mindarmour/images/dp_arch.png
new file mode 100644
index 0000000000000000000000000000000000000000..c903e4e2acece6c6de882852dc3570126b6fcb05
Binary files /dev/null and b/docs/note/source_en/design/mindarmour/images/dp_arch.png differ
diff --git a/docs/source_zh_cn/design/mindarmour/images/fuzz_architecture.png b/docs/note/source_en/design/mindarmour/images/fuzz_architecture.png
similarity index 100%
rename from docs/source_zh_cn/design/mindarmour/images/fuzz_architecture.png
rename to docs/note/source_en/design/mindarmour/images/fuzz_architecture.png
diff --git a/docs/source_zh_cn/design/mindarmour/images/fuzz_process.png b/docs/note/source_en/design/mindarmour/images/fuzz_process.png
similarity index 100%
rename from docs/source_zh_cn/design/mindarmour/images/fuzz_process.png
rename to docs/note/source_en/design/mindarmour/images/fuzz_process.png
diff --git a/docs/note/source_en/design/mindinsight.rst b/docs/note/source_en/design/mindinsight.rst
new file mode 100644
index 0000000000000000000000000000000000000000..21c8d10567454ddc2b6228ef79e4727dfdd2a2b3
--- /dev/null
+++ b/docs/note/source_en/design/mindinsight.rst
@@ -0,0 +1,9 @@
+MindInsight Design
+==================
+
+.. toctree::
+ :maxdepth: 1
+
+ mindinsight/training_visual_design
+ mindinsight/graph_visual_design
+ mindinsight/tensor_visual_design
\ No newline at end of file
diff --git a/docs/source_en/design/mindinsight/graph_visual_design.md b/docs/note/source_en/design/mindinsight/graph_visual_design.md
similarity index 92%
rename from docs/source_en/design/mindinsight/graph_visual_design.md
rename to docs/note/source_en/design/mindinsight/graph_visual_design.md
index 64f6b32d4589d64262586d3b2630bf61d15a7d64..ada9d8274ef4348f4d483cd2ef71bfb2083505ce 100644
--- a/docs/source_en/design/mindinsight/graph_visual_design.md
+++ b/docs/note/source_en/design/mindinsight/graph_visual_design.md
@@ -15,7 +15,7 @@
-
+
## Background
@@ -71,4 +71,4 @@ RESTful API is used for data interaction between the MindInsight frontend and ba
#### File API Design
Data interaction between MindSpore and MindInsight uses the data format defined by [Protocol Buffer](https://developers.google.cn/protocol-buffers/docs/pythontutorial).
-The main entry is the [summary.proto file](https://gitee.com/mindspore/mindinsight/blob/master/mindinsight/datavisual/proto_files/mindinsight_summary.proto). A message object of a computational graph is defined as `GraphProto`. For details about `GraphProto`, see the [anf_ir.proto file](https://gitee.com/mindspore/mindinsight/blob/master/mindinsight/datavisual/proto_files/mindinsight_anf_ir.proto).
\ No newline at end of file
+The main entry is the [summary.proto file](https://gitee.com/mindspore/mindinsight/blob/r1.0/mindinsight/datavisual/proto_files/mindinsight_summary.proto). A message object of a computational graph is defined as `GraphProto`. For details about `GraphProto`, see the [anf_ir.proto file](https://gitee.com/mindspore/mindinsight/blob/r1.0/mindinsight/datavisual/proto_files/mindinsight_anf_ir.proto).
\ No newline at end of file
diff --git a/docs/source_en/design/mindinsight/images/graph_visual_class_design.png b/docs/note/source_en/design/mindinsight/images/graph_visual_class_design.png
similarity index 100%
rename from docs/source_en/design/mindinsight/images/graph_visual_class_design.png
rename to docs/note/source_en/design/mindinsight/images/graph_visual_class_design.png
diff --git a/tutorials/source_en/advanced_use/images/graph.png b/docs/note/source_en/design/mindinsight/images/graph_visual_main.png
similarity index 100%
rename from tutorials/source_en/advanced_use/images/graph.png
rename to docs/note/source_en/design/mindinsight/images/graph_visual_main.png
diff --git a/tutorials/source_en/advanced_use/images/graph_sidebar.png b/docs/note/source_en/design/mindinsight/images/graph_visual_right_side.png
similarity index 100%
rename from tutorials/source_en/advanced_use/images/graph_sidebar.png
rename to docs/note/source_en/design/mindinsight/images/graph_visual_right_side.png
diff --git a/docs/source_en/design/mindinsight/images/tensor_histogram.png b/docs/note/source_en/design/mindinsight/images/tensor_histogram.png
similarity index 100%
rename from docs/source_en/design/mindinsight/images/tensor_histogram.png
rename to docs/note/source_en/design/mindinsight/images/tensor_histogram.png
diff --git a/tutorials/source_en/advanced_use/images/tensor_table.png b/docs/note/source_en/design/mindinsight/images/tensor_table.png
similarity index 100%
rename from tutorials/source_en/advanced_use/images/tensor_table.png
rename to docs/note/source_en/design/mindinsight/images/tensor_table.png
diff --git a/docs/source_en/design/mindinsight/images/training_visualization_architecture.png b/docs/note/source_en/design/mindinsight/images/training_visualization_architecture.png
similarity index 100%
rename from docs/source_en/design/mindinsight/images/training_visualization_architecture.png
rename to docs/note/source_en/design/mindinsight/images/training_visualization_architecture.png
diff --git a/docs/source_en/design/mindinsight/images/training_visualization_data_flow.png b/docs/note/source_en/design/mindinsight/images/training_visualization_data_flow.png
similarity index 100%
rename from docs/source_en/design/mindinsight/images/training_visualization_data_flow.png
rename to docs/note/source_en/design/mindinsight/images/training_visualization_data_flow.png
diff --git a/docs/source_en/design/mindinsight/images/training_visualization_data_model.png b/docs/note/source_en/design/mindinsight/images/training_visualization_data_model.png
similarity index 100%
rename from docs/source_en/design/mindinsight/images/training_visualization_data_model.png
rename to docs/note/source_en/design/mindinsight/images/training_visualization_data_model.png
diff --git a/docs/source_en/design/mindinsight/tensor_visual_design.md b/docs/note/source_en/design/mindinsight/tensor_visual_design.md
similarity index 83%
rename from docs/source_en/design/mindinsight/tensor_visual_design.md
rename to docs/note/source_en/design/mindinsight/tensor_visual_design.md
index ce3839d5b9affa269ccf802cf10a697412a82b78..5ca954c45a1a337e38c8a1f52f6e1043b14f597a 100644
--- a/docs/source_en/design/mindinsight/tensor_visual_design.md
+++ b/docs/note/source_en/design/mindinsight/tensor_visual_design.md
@@ -14,7 +14,7 @@
-
+
## Background
@@ -44,7 +44,7 @@ Figure 1: Table view
Figure 1 displays tensors recorded by a user in a form of a table. The following functions are included:
-- The input boxes under the table display the tensor data of the current dimension. The colon (:) indicates all values of the current dimension. You can enter the corresponding index in the box (the meaning is the same as that of the Python index, and negative values are supported) or use `:` to query tensor data in a specific dimension.
+- The input boxes under the table display the tensor data of the current dimension. The colon (:) indicates index range of the current dimension which is basically the same as the meaning of Python index. If no specific index is specified, it indicates all the values of the current dimension and `2:5` indicates the value of index from 2 to 5 (not including 5). You can enter the corresponding index in the box or use index range containing `:` to query tensor data in a specific dimension.
- Drag the thumb of the linear slider below the table to query the tensor data of a specific step.
@@ -55,7 +55,7 @@ Figure 2 shows tensors recorded by a user in a form of a histogram.
### API Design
-In tensor visualization, there are file API and RESTful API. The file API is the [summary.proto](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/utils/summary.proto) file, which is used for data interconnection between MindInsight and MindSpore. RESTful API is an internal API used for data interaction between the MindInsight frontend and backend.
+In tensor visualization, there are file API and RESTful API. The file API is the [summary.proto](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/utils/summary.proto) file, which is used for data interconnection between MindInsight and MindSpore. RESTful API is an internal API used for data interaction between the MindInsight frontend and backend.
#### File API Design
@@ -100,4 +100,4 @@ The `summary.proto` file is the main entry. TensorProto data is stored in the su
repeated Value value = 1;
}
```
-TensorProto is defined in the [anf_ir.proto](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/utils/anf_ir.proto) file.
\ No newline at end of file
+TensorProto is defined in the [anf_ir.proto](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/utils/anf_ir.proto) file.
\ No newline at end of file
diff --git a/docs/source_en/design/mindinsight/training_visual_design.md b/docs/note/source_en/design/mindinsight/training_visual_design.md
similarity index 94%
rename from docs/source_en/design/mindinsight/training_visual_design.md
rename to docs/note/source_en/design/mindinsight/training_visual_design.md
index 599a44df3b974494a1900902f799ed6a6c1e765d..58876603c59dcb57d13dc5779ddc8813f4543f93 100644
--- a/docs/source_en/design/mindinsight/training_visual_design.md
+++ b/docs/note/source_en/design/mindinsight/training_visual_design.md
@@ -18,7 +18,7 @@
-
+
[MindInsight](https://gitee.com/mindspore/mindinsight) is a visualized debugging and tuning component of MindSpore. MindInsight can be used to complete tasks such as training visualization, performance tuning, and precision tuning.
@@ -40,11 +40,11 @@ The training information collection function in MindSpore consists of training i
Training information collection APIs include:
-- Training information collection API based on the summary operator. This API contains four summary operators, that is, the ScalarSummary operator for recording scalar data, the ImageSummary operator for recording image data, the HistogramSummary operator for recording parameter distribution histogram data, and the TensorSummary operator for recording tensor data. For details about the operators, see [Operator List](https://www.mindspore.cn/docs/en/master/operator_list.html).
+- Training information collection API based on the summary operator. This API contains four summary operators, that is, the ScalarSummary operator for recording scalar data, the ImageSummary operator for recording image data, the HistogramSummary operator for recording parameter distribution histogram data, and the TensorSummary operator for recording tensor data. For details about the operators, see [Operator List](https://www.mindspore.cn/doc/note/en/r1.0/operator_list.html).
-- Training information collection API based on the Python API. You can use the [SummaryRecord.add_value](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.train.html#mindspore.train.summary.SummaryRecord.add_value) method to collect training information in Python code.
+- Training information collection API based on the Python API. You can use the [SummaryRecord.add_value](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.train.html#mindspore.train.summary.SummaryRecord.add_value) method to collect training information in Python code.
-- Easy-to-use training information collection callback. The [SummaryCollector](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.train.html#mindspore.train.callback.SummaryCollector) callback function can be used to conveniently collect common training information to training logs.
+- Easy-to-use training information collection callback. The [SummaryCollector](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.train.html#mindspore.train.callback.SummaryCollector) callback function can be used to conveniently collect common training information to training logs.
The training information persistence module mainly includes a summary_record module used to manage a cache and a write_pool module used to process data in parallel and write data into a file. After the training information is made persistent, it is stored in the training log file (summary file).
diff --git a/docs/note/source_en/design/mindspore.rst b/docs/note/source_en/design/mindspore.rst
new file mode 100644
index 0000000000000000000000000000000000000000..c10bd35f4a4fdd734cbc37725c2a9f0b10c78179
--- /dev/null
+++ b/docs/note/source_en/design/mindspore.rst
@@ -0,0 +1,10 @@
+MindSpore Design
+================
+
+.. toctree::
+ :maxdepth: 1
+
+ mindspore/mindir
+ mindspore/distributed_training_design
+ mindspore/profiler_design
+
diff --git a/docs/source_en/architecture.md b/docs/note/source_en/design/mindspore/architecture.md
similarity index 89%
rename from docs/source_en/architecture.md
rename to docs/note/source_en/design/mindspore/architecture.md
index 43cf28ef2fa68e47a8c50d59d3fd5ad752fb280b..9b59fc4291c0bb59df24518ebb3f854f98b3832e 100644
--- a/docs/source_en/architecture.md
+++ b/docs/note/source_en/design/mindspore/architecture.md
@@ -2,7 +2,7 @@
`Linux` `Windows` `Ascend` `GPU` `CPU` `On Device` `Model Development` `Model Optimization` `Framework Development` `Intermediate` `Expert` `Contributor`
-
+
The MindSpore framework consists of the Frontend Expression layer, Graph Engine layer, and Backend Runtime layer.
diff --git a/lite/docs/source_en/architecture.md b/docs/note/source_en/design/mindspore/architecture_lite.md
similarity index 83%
rename from lite/docs/source_en/architecture.md
rename to docs/note/source_en/design/mindspore/architecture_lite.md
index 64585775720d39c365190d9f8f24c82931cf24e3..5023c99fdea161f73e13cb7995eefdb5d9049737 100644
--- a/lite/docs/source_en/architecture.md
+++ b/docs/note/source_en/design/mindspore/architecture_lite.md
@@ -1,6 +1,8 @@
-# Overall Architecture
+# Overall Architecture (Lite)
-
+`Linux` `Windows` `On Device` `Inference Application` `Intermediate` `Expert` `Contributor`
+
+
The overall architecture of MindSpore Lite is as follows:
diff --git a/docs/note/source_en/design/mindspore/distributed_training_design.md b/docs/note/source_en/design/mindspore/distributed_training_design.md
new file mode 100644
index 0000000000000000000000000000000000000000..e0331f804fb4551c67eb0688e9b1826afbf75504
--- /dev/null
+++ b/docs/note/source_en/design/mindspore/distributed_training_design.md
@@ -0,0 +1,144 @@
+# Distributed Training Design
+
+`Ascend` `GPU` `Model Development` `Model Optimization` `Framework Development` `Intermediate` `Expert` `Contributor`
+
+
+
+- [Distributed Training Design](#distributed-training-design)
+ - [Background](#background)
+ - [Concepts](#concepts)
+ - [Collective Communication](#collective-communication)
+ - [Synchronization Mode](#synchronization-mode)
+ - [Data Parallelism](#data-parallelism)
+ - [Principle of Data Parallelism](#principle-of-data-parallelism)
+ - [Data Parallel Code](#data-parallel-code)
+ - [Automatic Parallelism](#automatic-parallelism)
+ - [Principle of Automatic Parallelism](#principle-of-automatic-parallelism)
+ - [Automatic Parallel Code](#automatic-parallel-code)
+
+
+
+
+
+## Background
+
+With the rapid development of deep learning, the number of datasets and parameters are growing exponentially to improve the accuracy and generalization capability of neural networks. Parallel distributed training has become a development trend to resolve the performance bottleneck of ultra-large scale networks. MindSpore supports the mainstream distributed training paradigm and develops an automatic hybrid parallel solution. The following describes the design principles of several parallel training modes and provides guidance for users to perform custom development.
+
+
+## Concepts
+
+### Collective Communication
+
+Collective communication is defined as communication that involves a group of processes. All processes in the group send and receive data after meeting certain conditions. MindSpore implements data transmission during parallel training through collective communication. On Ascend chips, MindSpore depends on the Huawei Collective Communication Library (`HCCL`) to implement the task. On GPU, MindSpore depends on the NVIDIA Collective Communication Library (`NCCL`) to implement the task.
+
+### Synchronization Mode
+
+In synchronous mode, all devices strart training at the same time and update parameter values synchronously after the backward propagation algorithm is executed. Currently, MindSpore uses the synchronous training mode.
+
+## Data Parallelism
+
+This section describes how the data parallel mode `ParallelMode.DATA_PARALLEL` works in MindSpore.
+
+### Principle of Data Parallelism
+
+
+
+1. Environment dependencies
+
+ Each time before parallel training starts, the `mindspore.communication.init` API is called to initialize communication resources and the global communication group `WORLD_COMM_GROUP` is automatically created.
+
+2. Data distribution
+
+ The key of data parallelism is to split datasets based on the sample dimension and deliver the split datasets to different devices. Each dataset loading API provided by the `mindspore.dataset` module has the `num_shards` and `shard_id` parameters. The parameters are used to split a dataset into multiple datasets, perform cyclic sampling, and collect data of the `batch` size to each device. When the data volume is insufficient, the sampling restarts from the beginning.
+
+3. Network structure
+
+ The scripting method of data parallel network is the same as that of standalone network. This is because, although models of each device are executed independently during the forward and backward propagation processes, the same network structure is maintained. To ensure the synchronous training between devices, the initial values of corresponding network parameters must be the same. You are advised to set the same random number seed on each device by using `numpy.random.seed` to broadcast models.
+
+4. Gradient aggregation
+
+ Theoretically, the training effect of data parallel network should be the same as that of the standalone network. To ensure the consistency of the calculation logic, the `AllReduce` operator is inserted after gradient calculation to implement the gradient aggregation operation between devices. You can enable `mean` to average the sum of gradient values, or regard `mean` as a hyperparameter. Enabling `mean` is equivalent to reducing the learning rate by multiple times.
+
+5. Parameter update
+
+ Because the gradient aggregation operation is introduced, the models of each device perform parameter update with the same gradient value. Therefore, MindSpore implements a synchronous data parallel training mode. Theoretically, models trained by each device are the same. If the reduce operation on samples is involved on the network, the network output may be different. This is determined by the sharding attribute of data parallelism.
+
+### Data Parallel Code
+
+1. Collective communication
+
+ - [management.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/communication/management.py): This file covers the `helper` function APIs commonly used during the collective communication process, for example, the APIs for obtaining the number of clusters and device ID. When collective communication is executed on the Ascend chip, the framework loads the `libhccl.so` library file in the environment and uses it to call the communication APIs from the Python layer to the underlying layer.
+ - [comm_ops.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ops/operations/comm_ops.py): MindSpore encapsulates supported collective communication operations as operators and stores the operators in this file. The operators include `AllReduce`, `AllGather`, `ReduceScatter`, and `Broadcast`. `PrimitiveWithInfer` defines the attributes required by the operators, as well as the `shape` and `dtype` inference methods from the input to the output during graph composition.
+
+2. Gradient aggregation
+
+ - [grad_reducer.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/nn/wrap/grad_reducer.py): This file implements the gradient aggregation process. After the input parameter `grads` is expanded by using `HyperMap`, the `AllReduce` operator is inserted. The global communication group is used. You can also perform custom development by referring to this section based on your network requirements. In MindSpore, standalone and distributed execution shares a set of network encapsulation APIs. In the `Cell`, `ParallelMode` is used to determine whether to perform gradient aggregation. For details about the network encapsulation APIs, see the `TrainOneStepCell` code implementation.
+
+
+## Automatic Parallelism
+
+As a key feature of MindSpore, automatic parallelism is used to implement hybrid parallel training that combines automatic data parallelism and model parallelism. It aims to help users express the parallel algorithm logic using standalone scripts, reduce the difficulty of distributed training, improve the algorithm R&D efficiency, and maintain the high performance of training. This section describes how the automatic parallel mode `ParallelMode.AUTO_PARALLEL` and semi-automatic parallel mode `ParallelMode.SEMI_AUTO_PARALLEL` work in MindSpore.
+
+### Principle of Automatic Parallelism
+
+
+
+1. Distributed operator and tensor layout
+
+ As shown in the preceding figure, the automatic parallel process traverses the standalone forward ANF graphs and performs shard modeling on tensors in the unit of distributed operator, indicating how the input and output tensors of an operator are distributed to each device of the cluster, that is, the tensor layout. Users do not need to know which device runs which slice of a model. The framework automatically schedules and allocates model slices.
+
+ To obtain the tensor layout model, each operator has a shard strategy, which indicates the shard status of each input of the operator in the corresponding dimension. Generally, tensors can be sharded in any dimension as long as the value is a multiple of 2, and the even distribution principle is met. The following figure shows an example of the three-dimensional `BatchMatmul` operation. The parallel strategy consists of two tuples, indicating the sharding of `input` and `weight`, respectively. Elements in a tuple correspond to tensor dimensions one by one. `2^N` indicates the shard unit, and `1` indicates that the tuple is not sharded. If you want to express a parallel data shard strategy, that is, only data in the `batch` dimension of `input` is sharded, and data in other dimensions are not sharded, you can use `strategy=((2^N, 1, 1),(1, 1, 1))`. If you want to express a parallel model shard strategy, that is, only model in the non-`batch` dimension of `weight` is sharded, for example, only the `channel` dimension is sharded, you can use `strategy=((1, 1, 1),(1, 1, 2^N))`. If you want to express a hybrid parallel shard strategy, one of which is `strategy=((2^N, 1, 1),(1, 1, 2^N))`.
+
+ 
+
+ Based on the shard strategy of an operator, the framework automatically derives the distribution model of input tensors and output tensors of the operator. This distribution model consists of `device_matrix`, `tensor_shape`, and `tensor map`, which indicate the device matrix shape, tensor shape, and mapping between devices and tensor dimensions, respectively. Based on the tensor layout model, distributed operator determines whether to insert extra computation and communication operations in the graph to ensure that the operator computing logic is correct.
+
+2. Tensor Redistribution
+
+ When the output tensor model of an operator is inconsistent with the input tensor model of the next operator, computation and communication operations need to be introduced to implement the change between tensor layouts. The automatic parallel process introduces the tensor redistribution algorithm, which can be used to derive the communication conversion operations between random tensor layouts. The following three examples represent a parallel computing process of the formula `Z=(X×W)×V`, that is, a `MatMul` operation of two two-dimensional matrices, and show how to perform conversion between different parallel modes.
+
+ In example 1, the output of the first data parallel matrix multiplication is sharded in the row rection, and the input of the second model parallel matrix multiplication requires full tensors. The framework automatically inserts the `AllGather` operator to implement redistribution.
+
+ 
+
+ In example 2, the output of parallel matrix multiplication of the first model is sharded in the column direction, and the input of parallel matrix multiplication of the second model is sharded in the row direction. The framework automatically inserts a communication operator equivalent to the `AlltoAll` operation in collective communication to implement redistribution.
+
+ 
+
+ In example 3, an output shard mode of the first hybrid parallel matrix multiplication is the same as an input shard mode of the second hybrid parallel matrix multiplication. Therefore, redistribution does not need to be introduced. In the second matrix multiplication operation, the related dimensions of the two inputs are sharded. Therefore, the `AllReduce` operator needs to be inserted to ensure the operation correctness.
+
+ 
+
+ In general, this distributed representation breaks the boundary between data parallelism and model parallelism, making it easy to implement hybrid parallelism. From the perspective of scripts, users only need to construct a standalone network to express the parallel algorithm logic. Framework automatically shards the entire graph.
+
+3. Efficient parallel strategy search algorithm
+
+ The `SEMI_AUTO_PARALLEL` semi-automatic parallel mode indicates that you manually configure the parallel strategy for operators when you are familiar with the operator sharding representation. This mode is helpful for manual optimization, with certain commissioning difficulty. You need to master the parallel principle and obtain a high-performance parallel solution based on the network structure and cluster topology. To further help users accelerate the parallel network training process, the automatic parallel mode `AUTO_PARALLEL` introduces the automatic search feature of the parallel strategy on the basis of the semi-automatic parallel mode. Automatic parallelism builds cost models based on the hardware platform, and calculates the computation cost, memory cost, and communication cost of a certain amount of data and specific operators based on different parallel strategies Then, by using the dynamic programming algorithm or recursive programming algorithm and taking the memory upper limit of a single device as a constraint condition, a parallel strategy with optimal performance is efficiently searched out.
+
+ Strategy search replaces manual model sharding and provides a high-performance sharding solution within a short period of time, greatly reducing the threshold for parallel training.
+
+
+4. Convenient distributed automatic differentiation
+
+ In addition to forward network communication, the traditional manual model sharding needs to consider backward parallel computing. MindSpore encapsulates communication operations into operators and automatically generates backward propagation of communication operators based on the original automatic differentiation operations of the framework. Therefore, even during distributed training, users only need to pay attention to the forward propagation of the network to implement actual automatic parallel training.
+
+### Automatic Parallel Code
+
+1. Tensor layout model
+ - [tensor_layout](https://gitee.com/mindspore/mindspore/tree/r1.0/mindspore/ccsrc/frontend/parallel/tensor_layout): This directory contains the definitions and implementation of functions related to the tensor distribution model. `tensor_layout.h` declares the member variables `tensor_map_origin_`, `tensor_shape_`, and `device_arrangement_` required by a tensor distribution model. In `tensor_redistribution.h`, the related methods for implementing the `from_origin_` and `to_origin_` transformation between tensor distributions are declared. The deduced redistribution operation is stored in `operator_list_` and returned, in addition, the communication cost `comm_cost_`,, memory cost `memory_cost_`, and calculation cost `computation_cost_` required for redistribution are calculated.
+
+2. Distributed operators
+ - [ops_info](https://gitee.com/mindspore/mindspore/tree/r1.0/mindspore/ccsrc/frontend/parallel/ops_info): This directory contains the implementation of distributed operators. In `operator_info.h`, the base class `OperatorInfo` of distributed operator implementation is defined. A distributed operator to be developed shall inherit the base class and explicitly implement related imaginary functions. The `InferTensorInfo`, `InferTensorMap`, and `InferDevMatrixShape` functions define the algorithms for deriving the input and output tensor distribution model of the operator. The `InferForwardCommunication` and `InferMirrorOps` functions define the extra calculation and communication operations to be inserted for operator sharding. The `CheckStrategy` and `GenerateStrategies` functions define the parallel strategy validation and generation for the operator. According to the parallel strategy `SetCostUnderStrategy`, the parallel cost `operator_cost_` of the distributed operator is generated.
+
+3. Strategy search algorithm
+ - [auto_parallel](https://gitee.com/mindspore/mindspore/tree/r1.0/mindspore/ccsrc/frontend/parallel/auto_parallel): The shard strategy search algorithm is implemented in this directory. `graph_costmodel.h` defines the graph composition information. Each point indicates an operator `OperatorInfo`. The directed edge `edge_costmodel.h` indicates the input and output relationship of operators and the redistribution cost. `operator_costmodel.h` defines the cost model of each operator, including the calculation cost, communication cost, and memory cost. `dp_algorithm_costmodel.h` describes the main process of the dynamic planning algorithm, which consists of a series of graph operations. `costmodel.h` defines the data structures of cost and graph operations.
+
+4. Device management
+ - [device_manager.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/frontend/parallel/device_manager.h): This file is used to create and manage cluster device communication groups. The device matrix model is defined by `device_matrix.h`, and the communication domain is managed by `group_manager.h`.
+
+5. Entire graph sharding
+ - [step_auto_parallel.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/frontend/parallel/step_auto_parallel.h), and [step_parallel.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/frontend/parallel/step_parallel.h): The two files contain the core implementation of the automatic parallel process. `step_auto_parallel.h` calls the strategy search process and generates the `OperatorInfo` of the distributed operator. Then in `step_parallel.h`, processes such as operator sharding and tensor redistribution are processed to reconstruct the standalone computing graph in distributed mode.
+
+
+6. Backward propagation of communication operators
+ - [grad_comm_ops.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ops/_grad/grad_comm_ops.py): This file defines the backward propagation of communication operators, such as `AllReduce` and `AllGather`.
diff --git a/lite/docs/source_en/images/MindSpore-Lite-architecture.png b/docs/note/source_en/design/mindspore/images/MindSpore-Lite-architecture.png
similarity index 100%
rename from lite/docs/source_en/images/MindSpore-Lite-architecture.png
rename to docs/note/source_en/design/mindspore/images/MindSpore-Lite-architecture.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/analyser_class_profiler.png b/docs/note/source_en/design/mindspore/images/analyser_class_profiler.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/analyser_class_profiler.png
rename to docs/note/source_en/design/mindspore/images/analyser_class_profiler.png
diff --git a/docs/source_en/images/architecture.eddx b/docs/note/source_en/design/mindspore/images/architecture.eddx
similarity index 100%
rename from docs/source_en/images/architecture.eddx
rename to docs/note/source_en/design/mindspore/images/architecture.eddx
diff --git a/docs/source_en/images/architecture.png b/docs/note/source_en/design/mindspore/images/architecture.png
similarity index 100%
rename from docs/source_en/images/architecture.png
rename to docs/note/source_en/design/mindspore/images/architecture.png
diff --git a/docs/source_zh_cn/design/mindspore/images/auto_parallel.png b/docs/note/source_en/design/mindspore/images/auto_parallel.png
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/auto_parallel.png
rename to docs/note/source_en/design/mindspore/images/auto_parallel.png
diff --git a/docs/note/source_en/design/mindspore/images/context_profiler.png b/docs/note/source_en/design/mindspore/images/context_profiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..f11782ebfe473ddfaec9736055c9012a5129a26f
Binary files /dev/null and b/docs/note/source_en/design/mindspore/images/context_profiler.png differ
diff --git a/docs/note/source_en/design/mindspore/images/data_parallel.png b/docs/note/source_en/design/mindspore/images/data_parallel.png
new file mode 100644
index 0000000000000000000000000000000000000000..a92c82aa64615b398e83b9bc2cf0aa2c5db9f904
Binary files /dev/null and b/docs/note/source_en/design/mindspore/images/data_parallel.png differ
diff --git a/docs/source_en/design/mindspore/images/ir/cf.dot b/docs/note/source_en/design/mindspore/images/ir/cf.dot
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/cf.dot
rename to docs/note/source_en/design/mindspore/images/ir/cf.dot
diff --git a/docs/source_en/design/mindspore/images/ir/cf.png b/docs/note/source_en/design/mindspore/images/ir/cf.png
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/cf.png
rename to docs/note/source_en/design/mindspore/images/ir/cf.png
diff --git a/docs/source_en/design/mindspore/images/ir/closure.dot b/docs/note/source_en/design/mindspore/images/ir/closure.dot
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/closure.dot
rename to docs/note/source_en/design/mindspore/images/ir/closure.dot
diff --git a/docs/source_en/design/mindspore/images/ir/closure.png b/docs/note/source_en/design/mindspore/images/ir/closure.png
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/closure.png
rename to docs/note/source_en/design/mindspore/images/ir/closure.png
diff --git a/docs/source_en/design/mindspore/images/ir/hof.dot b/docs/note/source_en/design/mindspore/images/ir/hof.dot
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/hof.dot
rename to docs/note/source_en/design/mindspore/images/ir/hof.dot
diff --git a/docs/source_en/design/mindspore/images/ir/hof.png b/docs/note/source_en/design/mindspore/images/ir/hof.png
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/hof.png
rename to docs/note/source_en/design/mindspore/images/ir/hof.png
diff --git a/docs/source_en/design/mindspore/images/ir/ir.dot b/docs/note/source_en/design/mindspore/images/ir/ir.dot
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/ir.dot
rename to docs/note/source_en/design/mindspore/images/ir/ir.dot
diff --git a/docs/source_en/design/mindspore/images/ir/ir.png b/docs/note/source_en/design/mindspore/images/ir/ir.png
similarity index 100%
rename from docs/source_en/design/mindspore/images/ir/ir.png
rename to docs/note/source_en/design/mindspore/images/ir/ir.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/module_profiler.png b/docs/note/source_en/design/mindspore/images/module_profiler.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/module_profiler.png
rename to docs/note/source_en/design/mindspore/images/module_profiler.png
diff --git a/docs/source_zh_cn/design/mindspore/images/operator_split.png b/docs/note/source_en/design/mindspore/images/operator_split.png
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/operator_split.png
rename to docs/note/source_en/design/mindspore/images/operator_split.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/parser_module_profiler.png b/docs/note/source_en/design/mindspore/images/parser_module_profiler.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/parser_module_profiler.png
rename to docs/note/source_en/design/mindspore/images/parser_module_profiler.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/proposer_class_profiler.png b/docs/note/source_en/design/mindspore/images/proposer_class_profiler.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/proposer_class_profiler.png
rename to docs/note/source_en/design/mindspore/images/proposer_class_profiler.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/proposer_module_profiler.png b/docs/note/source_en/design/mindspore/images/proposer_module_profiler.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/proposer_module_profiler.png
rename to docs/note/source_en/design/mindspore/images/proposer_module_profiler.png
diff --git a/docs/note/source_en/design/mindspore/images/tensor_redistribution1.png b/docs/note/source_en/design/mindspore/images/tensor_redistribution1.png
new file mode 100644
index 0000000000000000000000000000000000000000..ed4d79416a0a07f8d75e738aa544d214834ae778
Binary files /dev/null and b/docs/note/source_en/design/mindspore/images/tensor_redistribution1.png differ
diff --git a/docs/note/source_en/design/mindspore/images/tensor_redistribution2.png b/docs/note/source_en/design/mindspore/images/tensor_redistribution2.png
new file mode 100644
index 0000000000000000000000000000000000000000..114f984c66ae578722dbcdbb59ab03c44dbcb097
Binary files /dev/null and b/docs/note/source_en/design/mindspore/images/tensor_redistribution2.png differ
diff --git a/docs/note/source_en/design/mindspore/images/tensor_redistribution3.png b/docs/note/source_en/design/mindspore/images/tensor_redistribution3.png
new file mode 100644
index 0000000000000000000000000000000000000000..dd66c9120615f50f2b3f60cfe139954cb4adf307
Binary files /dev/null and b/docs/note/source_en/design/mindspore/images/tensor_redistribution3.png differ
diff --git a/docs/source_zh_cn/design/mindinsight/images/time_order_profiler.png b/docs/note/source_en/design/mindspore/images/time_order_profiler.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/time_order_profiler.png
rename to docs/note/source_en/design/mindspore/images/time_order_profiler.png
diff --git a/docs/source_en/design/mindspore/ir.md b/docs/note/source_en/design/mindspore/mindir.md
similarity index 92%
rename from docs/source_en/design/mindspore/ir.md
rename to docs/note/source_en/design/mindspore/mindir.md
index 4837ba94baccb0f15638d6bb744ec13f9035bb1b..8dc2cf5b6c80e55fd9f5bd6e3d3ffa01dcf33f4a 100644
--- a/docs/source_en/design/mindspore/ir.md
+++ b/docs/note/source_en/design/mindspore/mindir.md
@@ -1,7 +1,7 @@
# MindSpore IR (MindIR)
-`Framework Development` `Intermediate` `Expert` `Contributor`
+`Linux` `Windows` `Framework Development` `Intermediate` `Expert` `Contributor`
@@ -18,7 +18,7 @@
-
+
## Overview
An intermediate representation (IR) is a representation of a program between the source and target languages, which facilitates program analysis and optimization for the compiler. Therefore, the IR design needs to consider the difficulty in converting the source language to the target language, as well as the ease-of-use and performance of program analysis and optimization.
@@ -77,7 +77,7 @@ lambda (x, y)
let c = b * %1 in
c end
```
-The corresponding MindIR is [ir.dot](./images/ir/ir.dot).
+The corresponding MindIR is [ir.dot](https://gitee.com/mindspore/docs/blob/r1.0/docs/note/source_en/design/mindspore/images/ir/ir.dot).
@@ -107,7 +107,7 @@ def hof(x):
return res
```
-The corresponding MindIR is [hof.dot](./images/ir/hof.dot).
+The corresponding MindIR is [hof.dot](https://gitee.com/mindspore/docs/blob/r1.0/docs/note/source_en/design/mindspore/images/ir/hof.dot).
In the actual network training scripts, the automatic derivation generic function `GradOperation` and `Partial` and `HyperMap` that are commonly used in the optimizer are typical high-order functions. Higher-order semantics greatly improve the flexibility and simplicity of MindSpore representations.
@@ -127,7 +127,7 @@ def fibonacci(n):
return fibonacci(n-1) + fibonacci(n-2)
```
-The corresponding MindIR is [cf.dot](./images/ir/cf.dot).
+The corresponding MindIR is [cf.dot](https://gitee.com/mindspore/docs/blob/r1.0/docs/note/source_en/design/mindspore/images/ir/cf.dot).
`fibonacci` is a top-level function graph. Two function graphs at the top level are selected and called by `switch`. `✓fibonacci` is the True branch of the first `if`, and `✗fibonacci` is the False branch of the first `if`. `✓✗fibonacci` called in `✗fibonacci` is the True branch of `elif`, and `✗✗fibonacci` is the False branch of `elif`. The key is, in a MindIR, conditional jumps and recursion are represented in the form of higher-order control flows. For example, `✓✗fibonacci` and `✗fibonacci` are transferred in as parameters of the `switch` operator. `switch` selects a function as the return value based on the condition parameter. In this way, `switch` performs a binary selection operation on the input functions as common values and does not call the functions. The real function call is completed on CNode following `switch`.
@@ -152,7 +152,7 @@ def ms_closure():
return out1, out2
```
-The corresponding MindIR is [closure.dot](./images/ir/closure.dot).
+The corresponding MindIR is [closure.dot](https://gitee.com/mindspore/docs/blob/r1.0/docs/note/source_en/design/mindspore/images/ir/closure.dot).
In the example, `a` and `b` are free variables because the variables `a` and `b` in `func_inner` are parameters defined in the referenced parent graph `func_outer`. The variable `closure` is a closure, which is the combination of the function `func_inner` and its context `func_outer(1, 2)`. Therefore, the result of `out1` is 4, which is equivalent to `1+2+1`, and the result of `out2` is 5, which is equivalent to `1+2+2`.
diff --git a/docs/note/source_en/design/mindspore/profiler_design.md b/docs/note/source_en/design/mindspore/profiler_design.md
new file mode 100644
index 0000000000000000000000000000000000000000..ce3ef43528d0bdc087b4403ec9b21cb358ce14cb
--- /dev/null
+++ b/docs/note/source_en/design/mindspore/profiler_design.md
@@ -0,0 +1,175 @@
+# Profiler Design Document
+
+`Ascend` `GPU` `Model Development` `Model Optimization` `Framework Development` `Intermediate` `Expert` `Contributor`
+
+
+
+- [Profiler Design Document](#profiler-design-document)
+ - [Background](#background)
+ - [Profiler Architecture Design](#profiler-architecture-design)
+ - [Context](#context)
+ - [Module Structure](#module-structure)
+ - [Internal Module Interaction](#internal-module-interaction)
+ - [Sub-Module Design](#sub-module-design)
+ - [ProfilerAPI and Controller](#profilerapi-and-controller)
+ - [Description](#description)
+ - [Design](#design)
+ - [Parser](#parser)
+ - [Description](#description-1)
+ - [Design](#design-1)
+ - [Analyser](#analyser)
+ - [Description](#description-2)
+ - [Design](#design-2)
+ - [Proposer](#proposer)
+ - [Description](#description-3)
+ - [Design](#design-3)
+
+
+
+
+
+## Background
+
+To support model development and performance debugging in MindSpore, an easy-to-use profile tool is required to intuitively display the performance information of each dimension of a network model, provide users with easy-to-use and abundant profiling functions, and help users quickly locate network performance faults.
+
+## Profiler Architecture Design
+The Profiler architecture design is introduced from the following three aspects: the overall context interaction relationship of Profiler; the internal structure of Profiler, including the module structure and module layers; the interactive calling relationship between modules.
+
+### Context
+
+Profiler is a part of the MindSpore debugging and optimization tool. The following figure shows the tool context.
+
+
+
+Figure 1 Context relationship
+
+As shown in the preceding figure, the interaction between the Profiler and other components is as follows:
+
+1. In the training script, MindSpore Profiler is called to send the command to the MindSpore ada communication module for starting performance data collection. Finally, the ada generates original performance data.
+
+2. MindSpore Profiler parses the original data in the user script and generates the intermediate data results in the specified folder.
+
+3. MindInsight Profiler connects to the intermediate data and provides the visualized Profiler function for users.
+### Module Structure
+
+Modules are classified into the following layers:
+
+
+
+Figure 2 Relationships between modules at different layers
+
+
+Module functions are as follows:
+1. ProfilerAPI is a calling entry provided by code, including the performance collection startup API and analysis API.
+2. Controller is a module at a layer lower than that of ProfilerAPI. It is called by the startup API of ProfilerAPI to start or stop the performance collection function. The original data is written to a fixed position by ada.
+3. Parser is a module for parsing original performance data which is collected on the device and cannot be directly understood by users. Parser parses, combines, and converts the data to generate intermediate results that can be understood by users and analyzed by upper layers.
+4. Analyser obtains the intermediate results parsed by the lower-layer Parser, encapsulates, filters, and sorts the intermediate results, and returns the various information to the upper-layer Profiler API and RESTful.
+5. RESTful is used to call the common API provided by the backend Analyser to obtain objective data and use RESTful to connect to the frontend.
+
+### Internal Module Interaction
+Users can use API or RESTful to complete internal module interaction process. The following uses the API as an example:
+
+
+
+Figure 3 Module interaction
+
+The interaction process of each module is as follows:
+
+1. ProfilerAPI calls the control function of the lower-layer Controller to control the lower-layer collection module to collect performance information. Currently, the collection module (ada) receives commands in resident process mode and independently collects performance information.
+
+2. After the training is complete, users call the analysis API of ProfilerAPI.
+
+3. Profiler API analysis API uses the Parser module to parse performance data, generates intermediate results, calls the Aalayser module to analyze the results, and returns various information to users.
+
+## Sub-Module Design
+### ProfilerAPI and Controller
+
+#### Description
+ProfilerAPI provides an entry API in the training script for users to start performance collection and analyze performance data.
+ProfilerAPI delivers commands through Controller to control the startup of ada.
+
+#### Design
+ProfilerAPI belongs to the API layer of upper-layer application and is integrated by the training script. The function is divided into two parts:
+
+- Before training, call the bottom-layer Controller API to deliver a command to start a profiling task.
+
+- After training, call the bottom-layer Controller API to deliver commands to stop the profiling task, call the Analyser and Parser APIs to parse data files and generate result data such as operator performance statistics and training trace statistics.
+
+
+Controller provides an API for the upper layer, calls API of the lower-layer performance collection module, and delivers commands for starting and stopping performance collection.
+
+The generated original performance data includes:
+
+- `hwts.log.data.45.dev.profiler_default_tag` file: stores operator execution information, including the start and end of a task and stream ID.
+- `DATA_PREPROCESS.dev.AICPU` file: specifies AI CPU operator execution time at each stage.
+- `Framework.host.task_desc_info` file: stores the mapping between operator IDs and operator names and the input and output information of each operator.
+- `training_trace.46.dev.profiler_default_tag` file: stores the start and end time of each step and time of step interval, forward and backward propagation, and step tail.
+
+### Parser
+#### Description
+Parser is a module for parsing original performance data which is collected on the device and cannot be directly understood by users. Parser parses, combines, and converts the data to generate intermediate results that can be understood by users and analyzed by upper layers.
+#### Design
+
+
+Figure 4 Parser module
+
+As shown in the preceding figure, there are HWTS Parser, AI CPU Parser, Framework Parser, and Training Trace Parser modules. Each module parses a type of original data to obtain the intermediate file that can be read by users.
+
+- HWTS Parser: parses the `hwts.log.data.45.dev.profiler_default_tag` file to obtain the task-based statistics of the device, such as the start and end of each task and stream ID, which are used to compute the operator execution time.
+- AI CPU Parser: parses the `DATA_PREPROCESS.dev.AICPU` file to obtain the AI CPU operator execution time at each stage.
+- Framework Parser: parses the `Framework.host.task_desc_info` file to obtain the mapping between AI Core operator and task, and key operator information.
+- Training Trace Parser: parses the `training_trace.46.dev.profiler_default_tag` file to analyze the time at each training stage.
+
+### Analyser
+
+#### Description
+Analyzer is used to filter, sort, query, and page the intermediate results generated at the parsing stage.
+
+#### Design
+
+This module parses the intermediate files generated by Parser, provides a general API for upper-layer data analysis, and returns the analyzed data to the upper layer for display. Various intermediate files have certain common points which can be abstracted. Therefore, following figure shows the design of the Analyser class.
+
+
+
+Figure 5 Analyser class
+
+As shown in the preceding figure, multiple Analysers are implemented for different contents to be queried. Filter, sorting, and pagination conditions can be defined for each Analyser. Each Analyser knows which intermediate files are required to merge, filter, and sort data. Analyser is associated with Parser through the intermediate files generated by Parser, and no function is called. In this way, Analyser and Parser are decoupled.
+
+Currently, there are two types of analyzers for operator information:
+
+- Filter the average information of operator types.
+- Filter the detailed average information of each operator in two Analysers (AicoreTypeAnalyser and AicoreDetailAnalyser).
+
+To hide the internal implementation of Analyser and facilitate calling, the simple factory mode is used to obtain the specified Analyser through AnalyserFactory.
+
+
+### Proposer
+#### Description
+Proposer is a Profiler performance optimization suggestion module. Proposer calls the Analyser module to obtain performance data, analyzes the performance data based on optimization rules, and displays optimization suggestions for users through the UI and API.
+
+#### Design
+
+Modules are classified into the following layers:
+
+
+
+Figure 6 Proposer module
+
+As shown in the preceding figure:
+
+- Proposer provides API for calling the API and RESTful to obtain optimization suggestions.
+- Proposer calls the Analyser API to obtain performance data and obtain optimization suggestions based on optimization rules.
+- Proposer calls Analyser factory to obtain the Analyser object.
+
+You can call the query API of the Analyser object to obtain information, including the top N AICore, AICoreType, and AICpu operators that are sorted by time and the time information of each traning trace stage.
+
+The following figure shows the module class design:
+
+
+
+Figure 7 Proposer class
+
+As shown in the preceding figure:
+
+- Proposers of various types inherit the abstract class Proposer and implement the analyze methods.
+- API and CLI call the ProposerFactory to obtain the Proposer and call the Proposer.analyze function to obtain the optimization suggestions of each type of Proposer.
\ No newline at end of file
diff --git a/docs/note/source_en/design/overall.rst b/docs/note/source_en/design/overall.rst
new file mode 100644
index 0000000000000000000000000000000000000000..bec96d2c15254cf9a888536a6cab4aff59ef9c00
--- /dev/null
+++ b/docs/note/source_en/design/overall.rst
@@ -0,0 +1,8 @@
+Overall Design
+================
+
+.. toctree::
+ :maxdepth: 1
+
+ mindspore/architecture
+ mindspore/architecture_lite
diff --git a/docs/source_en/glossary.md b/docs/note/source_en/glossary.md
similarity index 85%
rename from docs/source_en/glossary.md
rename to docs/note/source_en/glossary.md
index ae1fb21e9168f00bd574fdef787b2a7b3a86f831..c90722a69a5d5818b3e00f6ab2f933d4bc7bcdc3 100644
--- a/docs/source_en/glossary.md
+++ b/docs/note/source_en/glossary.md
@@ -2,7 +2,7 @@
`Linux` `Windows` `Ascend` `GPU` `CPU` `Whole Process` `Beginner` `Intermediate` `Expert`
-
+
| Acronym and Abbreviation | Description |
| ----- | ----- |
@@ -32,9 +32,10 @@
| LSTM | Long short-term memory, an artificial recurrent neural network (RNN) architecture used for processing and predicting an important event with a long interval and delay in a time sequence. |
| Manifest | A data format file. Huawei ModelArt adopts this format. For details, see
+
This document describes how to seek help and support when you encounter problems in using MindSpore. The following flowchart shows the overall help-seeking process which starts from users encountering a problem in using MindSpore and ends with they finding a proper solution. Help-seeking methods are introduced based on the flowchart.
diff --git a/docs/note/source_en/image_classification_lite.md b/docs/note/source_en/image_classification_lite.md
new file mode 100644
index 0000000000000000000000000000000000000000..659cb47a93b3e7a34370ad02a17b0e8195cb41af
--- /dev/null
+++ b/docs/note/source_en/image_classification_lite.md
@@ -0,0 +1,32 @@
+# Image Classification Model Support (Lite)
+
+
+
+## Image classification introduction
+
+Image classification is to identity what an image represents, to predict the object list and the probabilites. For example，the following tabel shows the classification results after mode inference.
+
+
+
+| Category | Probability |
+| ---------- | ----------- |
+| plant | 0.9359 |
+| flower | 0.8641 |
+| tree | 0.8584 |
+| houseplant | 0.7867 |
+
+Using MindSpore Lite to realize image classification [example](https://gitee.com/mindspore/mindspore/tree/r1.0/model_zoo/official/lite/image_classification).
+
+## Image classification model list
+
+The following table shows the data of some image classification models using MindSpore Lite inference.
+
+> The performance of the table below is tested on the mate30.
+
+| Model name | Size(Mb) | Top1 | Top5 | F1 | CPU 4 thread delay (ms) |
+|-----------------------| :----------: | :----------: | :----------: | :----------: | :-----------: |
+| [MobileNetV2](https://download.mindspore.cn/model_zoo/official/lite/mobilenetv2_openimage_lite/mobilenetv2.ms) | 11.5 | - | - | 65.5% | 14.595 |
+| [Inceptionv3](https://download.mindspore.cn/model_zoo/official/lite/inceptionv3_lite/inceptionv3.ms) | 90.9 | 78.62% | 94.08% | - | 92.086 |
+| [Shufflenetv2](https://download.mindspore.cn/model_zoo/official/lite/shufflenetv2_lite/shufflenetv2.ms) | 8.8 | 67.74% | 87.62% | - | 8.303 |
+| [GoogleNet](https://download.mindspore.cn/model_zoo/official/lite/googlenet_lite/googlenet.ms) | 25.3 | 72.2% | 90.06% | - | 23.257 |
+| [ResNext50](https://download.mindspore.cn/model_zoo/official/lite/resnext50_lite/resnext50.ms) | 95.8 | 73.1% | 91.21% | - | 138.164 |
diff --git a/docs/source_en/images/help_seeking_path.png b/docs/note/source_en/images/help_seeking_path.png
similarity index 100%
rename from docs/source_en/images/help_seeking_path.png
rename to docs/note/source_en/images/help_seeking_path.png
diff --git a/lite/tutorials/source_en/images/lite_quick_start_app_result.png b/docs/note/source_en/images/image_classification_result.png
similarity index 100%
rename from lite/tutorials/source_en/images/lite_quick_start_app_result.png
rename to docs/note/source_en/images/image_classification_result.png
diff --git a/docs/note/source_en/images/object_detection.png b/docs/note/source_en/images/object_detection.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad5425c86393a9367701166796df42c9e4702988
Binary files /dev/null and b/docs/note/source_en/images/object_detection.png differ
diff --git a/docs/note/source_en/index.rst b/docs/note/source_en/index.rst
new file mode 100644
index 0000000000000000000000000000000000000000..a5f0ceb3358f8db222d9aa654ce42333e4fd16d1
--- /dev/null
+++ b/docs/note/source_en/index.rst
@@ -0,0 +1,42 @@
+.. MindSpore documentation master file, created by
+ sphinx-quickstart on Thu Mar 24 10:00:00 2020.
+ You can adapt this file completely to your liking, but it should at least
+ contain the root `toctree` directive.
+
+MindSpore Note
+================
+
+.. toctree::
+ :glob:
+ :maxdepth: 1
+ :caption: Design
+
+ design/overall
+ design/mindspore
+ design/mindinsight
+ design/mindarmour
+
+
+.. toctree::
+ :glob:
+ :maxdepth: 1
+ :caption: Specification Note
+
+ benchmark
+ network_list
+ operator_list
+ constraints_on_network_construction
+ image_classification_lite
+ object_detection_lite
+
+.. toctree::
+ :glob:
+ :maxdepth: 1
+ :caption: Others
+
+ glossary
+ roadmap
+ help_seeking_path
+ community
+
+
\ No newline at end of file
diff --git a/tutorials/source_zh_cn/use/data_preparation.rst b/docs/note/source_en/network_list.rst
similarity index 34%
rename from tutorials/source_zh_cn/use/data_preparation.rst
rename to docs/note/source_en/network_list.rst
index c7b3c2a76a97608e77e5dd00672ce26e32cc8068..f149a7e9bcd148abd3f6b933fa1597da008bab20 100644
--- a/tutorials/source_zh_cn/use/data_preparation.rst
+++ b/docs/note/source_en/network_list.rst
@@ -1,9 +1,7 @@
-准备数据
-========
+Network List
+==============
.. toctree::
:maxdepth: 1
- image_loading
- text_loading
-
+ network_list_ms
\ No newline at end of file
diff --git a/docs/note/source_en/network_list_ms.md b/docs/note/source_en/network_list_ms.md
new file mode 100644
index 0000000000000000000000000000000000000000..e7fd9ff32e7f2453b7bc1538e50159eab0dffebe
--- /dev/null
+++ b/docs/note/source_en/network_list_ms.md
@@ -0,0 +1,49 @@
+# MindSpore Network List
+
+`Linux` `Ascend` `GPU` `CPU` `Model Development` `Intermediate` `Expert`
+
+
+
+- [MindSpore Network List](#mindspore-network-list)
+ - [Model Zoo](#model-zoo)
+
+
+
+
+
+## Model Zoo
+
+| Domain | Sub Domain | Network | Ascend(Graph) | Ascend(PyNative) | GPU(Graph) | GPU(PyNative)| CPU(Graph)
+|:------ |:------| :----------- |:------ |:------ |:------ |:------ |:-----
+|Computer Vision (CV) | Image Classification | [AlexNet](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/alexnet/src/alexnet.py) | Supported | Supported | Supported | Supported | Doing
+| Computer Vision (CV) | Image Classification | [GoogleNet](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/googlenet/src/googlenet.py) | Supported | Supported | Supported | Supported | Doing
+| Computer Vision (CV) | Image Classification | [LeNet](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/lenet/src/lenet.py) | Supported | Supported | Supported | Supported | Supported
+| Computer Vision (CV) | Image Classification | [ResNet-50](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Supported | Supported | Supported | Doing
+|Computer Vision (CV) | Image Classification | [ResNet-101](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Supported | Supported | Supported | Doing
+|Computer Vision (CV) | Image Classification | [SE-ResNet50](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Doing | Doing | Doing | Doing
+|Computer Vision (CV) | Image Classification | [ResNext50](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnext50/src/image_classification.py) | Supported | Supported | Supported | Supported | Doing
+| Computer Vision (CV) | Image Classification | [VGG16](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/vgg16/src/vgg.py) | Supported | Supported | Supported | Supported | Doing
+| Computer Vision (CV) | Image Classification | [InceptionV3](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/inceptionv3/src/inception_v3.py) | Supported | Supported | Doing | Doing | Doing
+| Computer Vision (CV) | Image Classification | [DenseNet121](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/densenet121/src/network/densenet.py) | Supported | Doing | Doing | Doing | Doing
+| Computer Vision (CV) | Mobile Image Classification
+
+## Object dectectin introduction
+
+Object detection can identify the object in the image and its position in the image. For the following figure, the output of the object detection model is shown in the following table. The rectangular box is used to identify the position of the object in the graph and the probability of the object category is marked. The four numbers in the coordinates are Xmin, Ymin, Xmax, Ymax; the probability represents the probility of the detected object.
+
+
+
+| Category | Probability | Coordinate |
+| -------- | ----------- | ---------------- |
+| mouse | 0.78 | [10, 25, 35, 43] |
+
+Using MindSpore Lite to implement object detection [example](https://gitee.com/mindspore/mindspore/tree/r1.0/model_zoo/official/lite/object_detection).
+
+## Object detection model list
+
+The following table shows the data of some object detection models using MindSpore Lite inference.
+
+> The performance of the table below is tested on the mate30.
+
+| Model name | Size | mAP(IoU=0.50:0.95) | CPU 4 thread delay (ms) |
+|-----------------------| :----------: | :----------: | :-----------: |
+| [MobileNetv2-SSD](https://download.mindspore.cn/model_zoo/official/lite/ssd_mobilenetv2_lite/ssd.ms) | 16.7 | 0.22 | 25.4 |
+
diff --git a/docs/note/source_en/operator_list.rst b/docs/note/source_en/operator_list.rst
new file mode 100644
index 0000000000000000000000000000000000000000..f933918ac7981191d4f2aa61d2d2e6faea1b54e1
--- /dev/null
+++ b/docs/note/source_en/operator_list.rst
@@ -0,0 +1,10 @@
+Operator List
+===============
+
+.. toctree::
+ :maxdepth: 1
+
+ operator_list_ms
+ operator_list_implicit
+ operator_list_parallel
+ operator_list_lite
\ No newline at end of file
diff --git a/docs/note/source_en/operator_list_implicit.md b/docs/note/source_en/operator_list_implicit.md
new file mode 100644
index 0000000000000000000000000000000000000000..6936bfe00c89cca05e49d1913c08382a28bad2b3
--- /dev/null
+++ b/docs/note/source_en/operator_list_implicit.md
@@ -0,0 +1,104 @@
+# MindSpore Implicit Type Conversion Operator List
+
+`Linux` `Ascend` `GPU` `CPU` `Model Development` `Beginner` `Intermediate` `Expert`
+
+
+
+- [MindSpore Implicit Type Conversion Operator List](#mindspore-implicit-type-conversion-operator-list)
+ - [Implicit Type Conversion](#implicit-type-conversion)
+ - [conversion rules](#conversion-rules)
+ - [data types involved in conversion](#data-types-involved-in-conversion)
+ - [support ops](#support-ops)
+
+
+
+
+
+## Implicit Type Conversion
+
+### conversion rules
+
+- Scalar and Tensor operations: during operation, the scalar is automatically converted to Tensor, and the data type is consistent with the Tensor data type involved in the operation; when Tensor is a bool data type and the scalar is int or float, both the scalar and Tensor are converted to the Tensor with the data type of int32 or float32.
+- Tensor operation of different data types: the priority of data type is bool < uint8 < int8 < int16 < int32 < int64 < float16 < float32 < float64, during the operation, first determine the data type with the relatively highest priority among the Tensors involved in the operation, and then convert the low priority data type Tensor to the relatively highest priority data type; when the Tensor of int8 and uint8 data types are operated, they are converted to int16 Tensor.
+- Data type conversion of Parameter is not supported: If inferred according to the conversion rules, RuntimeError exception will be thrown when the data type conversion of Parameter defined in the network is required.
+
+### data types involved in conversion
+
+- bool
+- int8
+- uint8
+- int16
+- int32
+- int64
+- float16
+- float32
+- float64
+
+### support ops
+
+| op name
+| :-----------
+| [mindspore.ops.Assign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Assign)
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub)
+| [mindspore.ops.ApplyMomentum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyMomentum)
+| [mindspore.ops.FusedSparseAdam](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseAdam)
+| [mindspore.ops.FusedSparseLazyAdam](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseLazyAdam)
+| [mindspore.ops.FusedSparseFtrl](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseFtrl)
+| [mindspore.ops.FusedSparseProximalAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseProximalAdagrad)
+| [mindspore.ops.ApplyAdaMax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdaMax)
+| [mindspore.ops.ApplyAdadelta](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdadelta)
+| [mindspore.ops.ApplyAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdagrad)
+| [mindspore.ops.ApplyAdagradV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdagradV2)
+| [mindspore.ops.SparseApplyAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagrad)
+| [mindspore.ops.SparseApplyAdagradV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagradV2)
+| [mindspore.ops.ApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalAdagrad)
+| [mindspore.ops.SparseApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyProximalAdagrad)
+| [mindspore.ops.ApplyAddSign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAddSign)
+| [mindspore.ops.ApplyPowerSign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyPowerSign)
+| [mindspore.ops.ApplyGradientDescent](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyGradientDescent)
+| [mindspore.ops.ApplyProximalGradientDescent](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalGradientDescent)
+| [mindspore.ops.SparseApplyFtrl](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrl)
+| [mindspore.ops.SparseApplyFtrlV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrlV2)
+| [mindspore.ops.BitwiseAnd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseAnd)
+| [mindspore.ops.BitwiseOr](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseOr)
+| [mindspore.ops.BitwiseXor](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseXor)
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd)
+| [mindspore.ops.Sub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sub)
+| [mindspore.ops.Mul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mul)
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow)
+| [mindspore.ops.Minimum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Minimum)
+| [mindspore.ops.Maximum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Maximum)
+| [mindspore.ops.RealDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RealDiv)
+| [mindspore.ops.Div](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Div)
+| [mindspore.ops.DivNoNan](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DivNoNan)
+| [mindspore.ops.FloorDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorDiv)
+| [mindspore.ops.TruncateDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateDiv)
+| [mindspore.ops.TruncateMod](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateMod)
+| [mindspore.ops.Mod](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mod)
+| [mindspore.ops.FloorMod](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorMod)
+| [mindspore.ops.Atan2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Atan2)
+| [mindspore.ops.SquaredDifference](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SquaredDifference)
+| [mindspore.ops.Xdivy](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xdivy)
+| [mindspore.ops.Xlogy](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xlogy)
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal)
+| [mindspore.ops.ApproximateEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApproximateEqual)
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual)
+| [mindspore.ops.Greater](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Greater)
+| [mindspore.ops.GreaterEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GreaterEqual)
+| [mindspore.ops.Less](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Less)
+| [mindspore.ops.LessEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LessEqual)
+| [mindspore.ops.LogicalAnd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalAnd)
+| [mindspore.ops.LogicalOr](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalOr)
+| [mindspore.ops.ScatterNdUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdUpdate)
+| [mindspore.ops.ScatterNdAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdAdd)
+| [mindspore.ops.ScatterNdSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdSub)
+| [mindspore.ops.ScatterNonAliasingAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNonAliasingAdd)
+| [mindspore.ops.ScatterUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterUpdate)
+| [mindspore.ops.ScatterMax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMax)
+| [mindspore.ops.ScatterMin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMin)
+| [mindspore.ops.ScatterAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterAdd)
+| [mindspore.ops.ScatterSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterSub)
+| [mindspore.ops.ScatterMul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMul)
+| [mindspore.ops.ScatterDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterDiv)
+
+>
\ No newline at end of file
diff --git a/docs/note/source_en/operator_list_lite.md b/docs/note/source_en/operator_list_lite.md
new file mode 100644
index 0000000000000000000000000000000000000000..d758f6daacd5614a50337e858a831d59cf73bb55
--- /dev/null
+++ b/docs/note/source_en/operator_list_lite.md
@@ -0,0 +1,114 @@
+# MindSpore Lite Operator List
+
+`Linux` `On Device` `Inference Application` `Beginner` `Intermediate` `Expert`
+
+
+
+| Operation | CPU
+
+## mindspore.nn
+
+| Operation | Ascend | GPU | CPU |Operator Type
+| :----------- |:------ |:------ |:-----|:---
+| [mindspore.nn.Softmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Softmax) | Supported | Supported | Supported |layer/activation
+| [mindspore.nn.LogSoftmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LogSoftmax) | Supported | Supported | Doing |layer/activation
+| [mindspore.nn.ReLU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ReLU) | Supported | Supported | Supported |layer/activation
+| [mindspore.nn.ReLU6](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ReLU6) |Supported | Supported | Supported |layer/activation
+| [mindspore.nn.HSwish](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSwish) | Doing | Supported | Doing |layer/activation
+| [mindspore.nn.HSigmoid](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSigmoid) | Doing | Supported | Doing |layer/activation
+| [mindspore.nn.LeakyReLU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LeakyReLU) | Supported |Supported | Doing |layer/activation
+| [mindspore.nn.Tanh](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Tanh) | Supported | Supported | Doing |layer/activation
+| [mindspore.nn.GELU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GELU) | Supported | Supported | Doing |layer/activation
+| [mindspore.nn.Sigmoid](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Sigmoid) | Supported |Supported | Doing |layer/activation
+| [mindspore.nn.PReLU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.PReLU) | Supported |Doing | Doing |layer/activation
+| [mindspore.nn.Dropout](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Dropout) |Supported | Supported | Supported |layer/basic
+| [mindspore.nn.Flatten](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Flatten) |Supported | Supported | Supported |layer/basic
+| [mindspore.nn.Dense](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Dense) |Supported | Supported | Supported |layer/basic
+| [mindspore.nn.ClipByNorm](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ClipByNorm) |Supported | Supported | Doing |layer/basic
+| [mindspore.nn.Norm](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Norm) |Supported | Supported | Doing |layer/basic
+| [mindspore.nn.OneHot](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.OneHot) | Supported | Supported | Supported |layer/basic
+| [mindspore.nn.Range](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Range) | Supported | Doing | Doing |layer/basic
+| [mindspore.nn.SequentialCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SequentialCell) |Supported | Supported | Doing |layer/container
+| [mindspore.nn.CellList](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.CellList) | Supported | Supported | Doing |layer/container
+| [mindspore.nn.Conv2d](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2d) | Supported | Supported | Supported |layer/conv
+| [mindspore.nn.Conv2dTranspose](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dTranspose) | Supported | Supported | Doing |layer/conv
+| [mindspore.nn.Conv1d](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv1d) | Supported | Supported | Doing |layer/conv
+| [mindspore.nn.Conv1dTranspose](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv1dTranspose) | Supported | Supported | Doing |layer/conv
+| [mindspore.nn.Embedding](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Embedding) |Supported | Supported | Doing |layer/embedding
+| [mindspore.nn.ImageGradients](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ImageGradients) | Supported |Supported | Doing |layer/image
+| [mindspore.nn.SSIM](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SSIM) | Supported | Supported | Doing |layer/image
+| [mindspore.nn.PSNR](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.PSNR) | Supported |Supported | Doing |layer/image
+| [mindspore.nn.CentralCrop](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.CentralCrop) | Supported |Supported | Doing |layer/image
+| [mindspore.nn.LSTM](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LSTM) | Doing | Supported | Doing |layer/lstm
+| [mindspore.nn.LSTMCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LSTMCell) | Doing | Supported | Supported |layer/lstm
+| [mindspore.nn.GlobalBatchNorm](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GlobalBatchNorm) | Supported |Doing | Doing |layer/normalization
+| [mindspore.nn.BatchNorm1d](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm1d) | Supported |Doing | Doing |layer/normalization
+| [mindspore.nn.BatchNorm2d](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm2d) | Supported | Supported | Doing |layer/normalization
+| [mindspore.nn.GroupNorm](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GroupNorm) | Supported | Doing | Doing |layer/normalization
+| [mindspore.nn.LayerNorm](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LayerNorm) | Supported | Supported | Doing |layer/normalization
+| [mindspore.nn.MatrixDiag](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiag) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.MatrixDiagPart](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiagPart) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.MatrixSetDiag](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatrixSetDiag) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.LinSpace](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LinSpace) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.MaxPool2d](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MaxPool2d) | Supported | Supported | Supported |layer/pooling
+| [mindspore.nn.AvgPool2d](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.AvgPool2d) | Supported | Supported | Doing |layer/pooling
+| [mindspore.nn.DenseBnAct](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DenseBnAct) |Supported | Doing | Doing |layer/quant
+| [mindspore.nn.Conv2dBnAct](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnAct) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.FakeQuantWithMinMax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.FakeQuantWithMinMax) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.Conv2dBnFoldQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnFoldQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.Conv2dBnWithoutFoldQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnWithoutFoldQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.Conv2dQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.DenseQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DenseQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.ActQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ActQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.LeakyReLUQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LeakyReLUQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.HSwishQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSwishQuant) | Doing | Supported | Doing |layer/quant
+| [mindspore.nn.HSigmoidQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSigmoidQuant) | Doing | Supported | Doing |layer/quant
+| [mindspore.nn.TensorAddQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.TensorAddQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.MulQuant](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MulQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.L1Loss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.L1Loss) |Supported |Supported | Doing |loss/loss
+| [mindspore.nn.MSELoss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MSELoss) | Supported |Supported | Doing |loss/loss
+| [mindspore.nn.SmoothL1Loss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SmoothL1Loss) |Supported |Doing | Doing |loss/loss
+| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits) | Supported | Supported | Supported |loss/loss
+| [mindspore.nn.CosineEmbeddingLoss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.CosineEmbeddingLoss) |Supported |Supported | Doing |loss/loss
+| [mindspore.nn.ProximalAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ProximalAdagrad) | Supported | Doing | Doing |optim/ProximalAdagrad
+| [mindspore.nn.LazyAdam](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LazyAdam) | Supported | Doing | Doing |optim/lazyadam
+| [mindspore.nn.Adam](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Adam) | Supported |Doing | Doing |optim/adam
+| [mindspore.nn.AdamWeightDecay](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.AdamWeightDecay) | Supported | Supported | Doing |optim/adam
+| [mindspore.nn.Lamb](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Lamb) | Supported | Supported | Doing |optim/lamb
+| [mindspore.nn.LARS](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LARS) |Supported |Doing | Doing |optim/lars
+| [mindspore.nn.Momentum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Momentum) | Supported | Supported | Supported |optim/momentum
+| [mindspore.nn.Optimizer](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Optimizer) | Supported | Supported | Doing |optim/optimizer
+| [mindspore.nn.RMSProp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.RMSProp) | Supported | Support | Doing |optim/optimizer
+| [mindspore.nn.SGD](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SGD) |Supported |Doing | Doing |optim/sgd
+| [mindspore.nn.WithLossCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.WithLossCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.WithGradCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.WithGradCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.TrainOneStepCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.GetNextSingleOp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GetNextSingleOp) |Doing | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.WithEvalCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.WithEvalCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.ParameterUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ParameterUpdate) | Supported |Doing | Doing |wrap/cell_wrapper
+| [mindspore.nn.DistributedGradReducer](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DistributedGradReducer) | Supported |Doing | Doing |wrap/grad_reducer
+| [mindspore.nn.DynamicLossScaleUpdateCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DynamicLossScaleUpdateCell) | Supported |Supported | Doing |wrap/loss_scale
+| [mindspore.nn.FixedLossScaleUpdateCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.FixedLossScaleUpdateCell) | Supported |Supported | Doing |wrap/loss_scale
+| [mindspore.nn.TrainOneStepWithLossScaleCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepWithLossScaleCell) | Supported |Supported | Doing |wrap/loss_scale
+| [mindspore.nn.Cell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Cell) | Supported | Supported | Supported |cell
+| [mindspore.nn.EmbeddingLookup](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.EmbeddingLookup) |Supported | Supported | Supported |layer/embedding
+| [mindspore.nn.Pad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Pad) |Supported | Supported | Doing |layer/basic
+| [mindspore.nn.MatMul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatMul) |Supported | Doing | Doing |layer/math
+| [mindspore.nn.LGamma](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LGamma) |Supported | Doing | Doing |layer/math
+| [mindspore.nn.ReduceLogSumExp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ReduceLogSumExp) |Supported | Supported | Doing |layer/math
+| [mindspore.nn.MSSSIM](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MSSSIM) | Supported |Doing | Doing |layer/image
+
+## mindspore.ops
+
+| Operation | Ascend | GPU | CPU |Operator Type
+| :----------- |:------ |:------ |:-----|:---
+| [mindspore.ops.Flatten](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Flatten) | Supported | Supported |Supported | nn_ops
+| [mindspore.ops.Softmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softmax) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.Acosh](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Acosh) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.FloorMod](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorMod) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.Elu](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Elu) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.MirrorPad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MirrorPad) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.Unpack](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Unpack) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.Pack](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pack) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.L2Loss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.L2Loss) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.CTCLoss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CTCLoss) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.RNNTLoss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RNNTLoss) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.LogSoftmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogSoftmax) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.Softplus](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softplus) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.ReLU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLU) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.ReLU6](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLU6) | Supported | Supported |Supported | nn_ops
+| [mindspore.ops.HSwish](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HSwish) | Doing | Supported |Doing | nn_ops
+| [mindspore.ops.HSigmoid](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HSigmoid) | Doing | Supported |Doing | nn_ops
+| [mindspore.ops.Sigmoid](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sigmoid) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.Tanh](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tanh) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.BatchNorm](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchNorm) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.LRN](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LRN) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.Conv2D](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Conv2D) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.DepthwiseConv2dNative](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthwiseConv2dNative) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.DepthwiseConv2dNativeBackpropInput](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthwiseConv2dNativeBackpropInput) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.DepthwiseConv2dNativeiBackpropFilter](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthwiseConv2dNativeBackpropFilter) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.MaxPoolWithArgmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MaxPoolWithArgmax) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.MaxPool](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MaxPool) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.AvgPool](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AvgPool) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.Conv2DBackpropInput](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Conv2DBackpropInput) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.BiasAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BiasAdd) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.TopK](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TopK) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SoftmaxCrossEntropyWithLogits) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.SparseSoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseSoftmaxCrossEntropyWithLogits) | Doing | Supported | Supported | nn_ops
+| [mindspore.ops.ApplyMomentum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyMomentum) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.ApplyAddSign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAddSign) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyPowerSign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyPowerSign) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyGradientDescent](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyGradientDescent) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyProximalGradientDescent](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalGradientDescent) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyRMSProp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyRMSProp) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.ApplyCenteredRMSProp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyCenteredRMSProp) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.SparseApplyAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagrad) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.SparseApplyAdagradV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagradV2) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.SparseApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.FusedSparseProximalAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseProximalAdagrad) | Doing | Doing | Supported | nn_ops
+| [mindspore.ops.ApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.FusedSparseLazyAdam](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseLazyAdam) | Doing | Doing | Supported | nn_ops
+| [mindspore.ops.FusedSparseAdam](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseAdam) | Doing | Doing | Supported | nn_ops
+| [mindspore.ops.SmoothL1Loss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SmoothL1Loss) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.SGD](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SGD) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.LayerNorm](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LayerNorm) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.L2Normalize](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.L2Normalize) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.DropoutGenMask](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutGenMask) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.DropoutDoMask](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutDoMask) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ResizeBilinear](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ResizeBilinear) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.OneHot](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OneHot) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.Gelu](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Gelu) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.GetNext](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GetNext) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.PReLU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.PReLU) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.LSTM](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LSTM) | Doing | Supported | Supported | nn_ops
+| [mindspore.ops.BasicLSTMCell](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BasicLSTMCell) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SigmoidCrossEntropyWithLogits) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.Pad](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pad) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.ROIAlign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ROIAlign) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.Adam](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Adam) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.BinaryCrossEntropy](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BinaryCrossEntropy) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.KLDivLoss](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.KLDivLoss) | Doing | Supported | Doing | nn_ops
+| [mindspore.ops.LARSUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LARSUpdate) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.Softsign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softsign) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.AssignAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignAdd) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ReduceMean](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMean) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.ReduceSum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceSum) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.ReduceAll](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceAll) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ReduceMax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMax) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.ReduceMin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMin) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.ReduceProd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceProd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.CumProd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CumProd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.MatMul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MatMul) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.BatchMatMul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchMatMul) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.CumSum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CumSum) | Supported | Supported| Doing | math_ops
+| [mindspore.ops.AddN](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AddN) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.Neg](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Neg) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sub) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.Mul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mul) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.Square](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Square) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.SquareSumAll](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SquareSumAll) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Rsqrt](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rsqrt) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sqrt](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sqrt) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Reciprocal](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reciprocal) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Exp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Exp) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Log](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Log) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Log1p](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Log1p) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Minimum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Minimum) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Maximum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Maximum) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.RealDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RealDiv) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Div](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Div) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.DivNoNan](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DivNoNan) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.FloorDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorDiv) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Floor](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Floor) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.EqualCount](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.EqualCount) | Doing | Supported | Supported | math_ops
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Greater](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Greater) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.GreaterEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GreaterEqual) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Less](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Less) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Atan2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Atan2) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.LessEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LessEqual) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.LogicalNot](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalNot) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.LogicalAnd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalAnd) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.LogicalOr](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalOr) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.BitwiseAnd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseAnd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BitwiseOr](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseOr) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Ceil](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Ceil) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Inv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Inv) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Invert](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Invert) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BitwiseXor](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseXor) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NPUAllocFloatStatus](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NPUAllocFloatStatus) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NPUGetFloatStatus](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NPUGetFloatStatus) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NPUClearFloatStatus](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NPUClearFloatStatus) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.FloatStatus](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloatStatus) | Doing | Supported | Doing | math_ops
+| [mindspore.ops.Cos](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cos) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Cosh](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cosh) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ACos](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ACos) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BesselI0e](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BesselI0e) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BesselI1e](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BesselI1e) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.TruncateDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateDiv) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.TruncateMod](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateMod) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Tan](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tan) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Asin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Asin) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Asinh](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Asinh) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Erf](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Erf) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Erfc](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Erfc) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Sin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sin) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sinh](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sinh) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Expm1](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Expm1) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NMSWithMask](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NMSWithMask) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Abs](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Abs) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sign) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Round](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Round) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ApproximateEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApproximateEqual) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.InplaceAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InplaceAdd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.InplaceSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InplaceSub) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Mod](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mod) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ExpandDims](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ExpandDims) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.DType](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DType) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.SameTypeShape](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SameTypeShape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Cast](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cast) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.IsSubClass](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IsSubClass) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.IsInstance](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IsInstance) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Reshape](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reshape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Shape](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Shape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Squeeze](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Squeeze) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.Transpose](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Transpose) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.GatherV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherV2) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Split](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Split) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.Rank](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rank) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Size](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Size) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Fill](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Fill) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.OnesLike](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OnesLike) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ZerosLike](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ZerosLike) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.TupleToArray](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TupleToArray) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ScalarToArray](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarToArray) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ScalarToTensor](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarToTensor) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.InvertPermutation](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InvertPermutation) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Argmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Argmax) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Argmin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Argmin) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ArgMaxWithValue](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMaxWithValue) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ArgMinWithValue](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMinWithValue) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Tile](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tile) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.UnsortedSegmentSum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UnsortedSegmentSum) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.UnsortedSegmentMin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UnsortedSegmentMin) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.UnsortedSegmentProd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UnsortedSegmentProd) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Concat](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Concat) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ParallelConcat](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ParallelConcat) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Slice](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Slice) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Select](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Select) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.StridedSlice](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.StridedSlice) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Diag](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Diag) | Doing | Doing | Doing | array_ops
+| [mindspore.ops.DiagPart](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DiagPart) | Doing | Doing | Doing | array_ops
+| [mindspore.ops.Eye](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Eye) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ScatterNd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNd) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ResizeNearestNeighbor](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ResizeNearestNeighbor) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.GatherNd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherNd) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ApplyFtrl](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyFtrl) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.SparseApplyFtrl](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrl) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.FusedSparseFtrl](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseFtrl) | Doing | Doing | Supported | array_ops
+| [mindspore.ops.SparseApplyFtrlV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrlV2) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNdUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdUpdate) | Supported | Doing | Supported | array_ops
+| [mindspore.ops.ScatterUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterMul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMul) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterDiv) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.SpaceToDepth](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SpaceToDepth) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.DepthToSpace](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthToSpace) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.SpaceToBatch](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SpaceToBatch) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.SpaceToBatchND](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SpaceToBatchND) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.BatchToSpace](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchToSpace) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.BatchToSpaceND](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchToSpaceND) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.IsFinite](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IsFinite) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.InplaceUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InplaceUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterSub) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterMax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMax) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterMin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMin) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNdAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdAdd) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNdSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdSub) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNonAliasingAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNonAliasingAdd) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Rint](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rint) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ReverseV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReverseV2) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ReduceOp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceOp) | Supported | Supported | Doing | comm_ops
+| [mindspore.ops.AllReduce](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AllReduce) | Supported | Supported | Doing | comm_ops
+| [mindspore.ops.AllGather](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AllGather) | Supported | Supported | Doing | comm_ops
+| [mindspore.ops.ReduceScatter](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceScatter) | Doing | Supported | Doing | comm_ops
+| [mindspore.ops.Broadcast](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Broadcast) | Supported | Doing | Doing | comm_ops
+| [mindspore.ops.ControlDepend](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ControlDepend) | Supported | Supported | Supported | control_ops
+| [mindspore.ops.GeSwitch](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GeSwitch) | Doing | Doing | Doing | control_ops
+| [mindspore.ops.Merge](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Merge) | Doing | Doing | Doing | control_ops
+| [mindspore.ops.ScalarSummary](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.ImageSummary](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ImageSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.TensorSummary](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.HistogramSummary](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HistogramSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.InsertGradientOf](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InsertGradientOf) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.Print](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Print) | Supported | Doing | Doing | debug_ops
+| [mindspore.ops.Assign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Assign) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.BoundingBoxEncode](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BoundingBoxEncode) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.BoundingBoxDecode](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BoundingBoxDecode) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.PopulationCount](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.PopulationCount) | Supported | Doing | Doing | other_ops
+| [mindspore.ops.CheckValid](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CheckValid) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.IOU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IOU) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.MakeRefKey](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MakeRefKey) | Supported | Supported | Supported | other_ops
+| [mindspore.ops.InTopK](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InTopK) | Supported | Doing | Doing | other_ops
+| [mindspore.ops.StandardNormal](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.StandardNormal) | Supported | Supported | Doing | random_ops
+| [mindspore.ops.Gamma](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Gamma) | Supported | Doing | Doing | random_ops
+| [mindspore.ops.Poisson](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Poisson) | Supported | Doing | Doing | random_ops
+| [mindspore.ops.UniformInt](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UniformInt) | Supported | Supported | Doing | random_ops
+| [mindspore.ops.UniformReal](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UniformReal) | Supported | Supported | Doing | random_ops
+| [mindspore.ops.RandomChoiceWithMask](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RandomChoiceWithMask) | Supported| Supported | Doing | random_ops
+| [mindspore.ops.RandomCategorical](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RandomCategorical) | Supported| Doing | Doing | random_ops
+| [mindspore.ops.ScalarCast](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarCast) | Supported | Supported | Supported | inner_ops
+| [mindspore.ops.ReverseSequence](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReverseSequence) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.CropAndResize](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CropAndResize) | Supported | Doing | Doing | image_ops
+| [mindspore.ops.SquaredDifference](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SquaredDifference) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Xdivy](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xdivy) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Xlogy](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xlogy) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.HistogramFixedWidth](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HistogramFixedWidth) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Eps](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Eps) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.ReLUV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLUV2) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.BNTrainingReduce](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BNTrainingReduce) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.BNTrainingUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BNTrainingUpdate) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.AccumulateNV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AccumulateNV2) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ScatterUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.TensorScatterUpdate](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorScatterUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.IFMR](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IFMR) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.DynamicShape](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DynamicShape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Unique](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Unique) | Doing | Doing | Doing | array_ops
+
+## mindspore.ops.functional
+
+| Operation | functional Operation
+| :----------- | :-----------
+| [mindspore.ops.Pack](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pack) | pack
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd) | tensor_add
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub) | assign_sub
+| [mindspore.ops.AddN](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AddN) | addn
+| [mindspore.ops.Square](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Square) | square
+| [mindspore.ops.Sqrt](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sqrt) | sqrt
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal) | equal
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual) | not_equal
+| [mindspore.ops.LogicalNot](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalNot) | logical_not
+| [mindspore.ops.LogicalAnd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalAnd) | logical_and
+| [mindspore.ops.LogicalOr](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalOr) | logical_or
+| [mindspore.ops.ExpandDims](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ExpandDims) | expand_dims
+| [mindspore.ops.DType](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DType) | dtype
+| [mindspore.ops.Cast](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cast) | cast
+| [mindspore.ops.Reshape](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reshape) | reshape
+| [mindspore.ops.Shape](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Shape) | shape
+| [mindspore.ops.GatherV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherV2) | gather
+| [mindspore.ops.Rank](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rank) | rank
+| [mindspore.ops.Size](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Size) | size
+| [mindspore.ops.Fill](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Fill) | fill
+| [mindspore.ops.OnesLike](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OnesLike) | ones_like
+| [mindspore.ops.Tile](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tile) | tile
+| [mindspore.ops.Select](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Select) | select
+| [mindspore.ops.ScatterNd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNd) | scatter_nd
+| [mindspore.ops.GatherNd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherNd) | gather_nd
+| [mindspore.ops.ControlDepend](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ControlDepend) | control_depend
+| [mindspore.ops.Print](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Print) | print
+| [mindspore.ops.Assign](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Assign) | assign
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow) | tensor_pow
+
+> At present, functional supports some operators without attributes, which will be further completed in the future.
diff --git a/docs/note/source_en/operator_list_parallel.md b/docs/note/source_en/operator_list_parallel.md
new file mode 100644
index 0000000000000000000000000000000000000000..0685405dae687070784918154fc9dbb63df735f1
--- /dev/null
+++ b/docs/note/source_en/operator_list_parallel.md
@@ -0,0 +1,75 @@
+# MindSpore Distributed Operator List
+
+`Linux` `Ascend` `GPU` `CPU` `Model Development` `Beginner` `Intermediate` `Expert`
+
+
+
+- [MindSpore Distributed Operator List](#mindspore-distributed-operator-list)
+ - [Distributed Operator](#distributed-operator)
+
+
+
+
+
+## Distributed Operator
+
+| op name | constraints
+| :----------- | :-----------
+| [mindspore.ops.ACos](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ACos) | None
+| [mindspore.ops.Cos](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cos) | None
+| [mindspore.ops.LogicalNot](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalNot) | None
+| [mindspore.ops.Log](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Log) | None
+| [mindspore.ops.Exp](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Exp) | None
+| [mindspore.ops.LogSoftmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogSoftmax) | The logits can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
+| [mindspore.ops.Softmax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softmax) | The logits can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
+| [mindspore.ops.Tanh](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tanh) | None
+| [mindspore.ops.Gelu](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Gelu) | None
+| [mindspore.ops.ReLU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLU) | None
+| [mindspore.ops.Sqrt](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sqrt) | None
+| [mindspore.ops.Cast](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cast) | None
+| [mindspore.ops.Neg](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Neg) | None
+| [mindspore.ops.ExpandDims](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ExpandDims) | None
+| [mindspore.ops.Squeeze](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Squeeze) | None
+| [mindspore.ops.Square](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Square) | None
+| [mindspore.ops.Sigmoid](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sigmoid) | None
+| [mindspore.ops.Dropout](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Dropout) | Repeated calculation is not supported.
+| [mindspore.ops.Div](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Div) | None
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd) | None
+| [mindspore.ops.RealDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RealDiv) | None
+| [mindspore.ops.Mul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mul) | None
+| [mindspore.ops.Sub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sub) | None
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow) | None
+| [mindspore.ops.FloorDiv](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorDiv) | None
+| [mindspore.ops.Greater](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Greater) | None
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub) | None
+| [mindspore.ops.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SigmoidCrossEntropyWithLogits) | None
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal) | None
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual) | None
+| [mindspore.ops.Maximum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Maximum) | None
+| [mindspore.ops.Minimum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Minimum) | None
+| [mindspore.ops.BiasAdd](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BiasAdd) | None
+| [mindspore.ops.Concat](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Concat) | The input_x can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
+| [mindspore.ops.DropoutGenMask](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutGenMask) | Need to be used in conjunction with `DropoutDoMask`.
+| [mindspore.ops.DropoutDoMask](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutDoMask) | Need to be used in conjunction with `DropoutGenMask`，configuring shard strategy is not supported.
+| [mindspore.ops.GatherV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherV2) | Only support 1-dim and 2-dim parameters and the last dimension of the input_params should be 32-byte aligned; Scalar input_indices is not supported; Repeated calculation is not supported when the parameters are split in the dimension of the axis; Split input_indices and input_params at the same time is not supported.
+| [mindspore.ops.SparseGatherV2](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseGatherV2) | The same as GatherV2.
+| [mindspore.ops.EmbeddingLookup](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.EmbeddingLookup) | The same as GatherV2.
+| [mindspore.ops.L2Normalize](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.L2Normalize) | The input_x can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
+| [mindspore.ops.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SoftmaxCrossEntropyWithLogits) | The last dimension of logits and labels can't be splited; Only supports using output[0].
+| [mindspore.ops.MatMul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MatMul) | `transpose_a=True` is not supported.
+| [mindspore.ops.BatchMatMul](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchMatMul) | `transpore_a=True` is not supported.
+| [mindspore.ops.PReLU](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.PReLU) | When the shape of weight is not [1], the shard strategy in channel dimension of input_x should be consistent with weight.
+| [mindspore.ops.OneHot](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OneHot) | Only support 1-dim indices. Must configure strategy for the output and the first and second inputs.
+| [mindspore.ops.ReduceSum](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceSum) | None
+| [mindspore.ops.ReduceMax](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMax) | When the input_x is splited on the axis dimension, the distributed result may be inconsistent with that on the single machine.
+| [mindspore.ops.ReduceMin](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMin) | When the input_x is splited on the axis dimension, the distributed result may be inconsistent with that on the single machine.
+| [mindspore.ops.ArgMinWithValue](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMinWithValue) | When the input_x is splited on the axis dimension, the distributed result may be inconsistent with that on the single machine.
+| [mindspore.ops.ArgMaxWithValue](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMaxWithValue) | When the input_x is splited on the axis dimension, the distributed result may be inconsistent with that on the single machine.
+| [mindspore.ops.ReduceMean](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMean) | None
+| [mindspore.ops.Reshape](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reshape) | Configuring shard strategy is not supported.
+| [mindspore.ops.StridedSlice](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.StridedSlice) | Only support mask with all 0 values; The dimension needs to be split should be all extracted; Split is not supported when the strides of dimension is 1.
+| [mindspore.ops.Tile](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tile) | Only support configuring shard strategy for multiples.
+| [mindspore.ops.Transpose](https://www.mindspore.cn/doc/api_python/en/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Transpose) | None
+
+> Repeated calculation means that the device is not fully used. For example, the cluster has 8 devices to run distributed training, the splitting strategy only cuts the input into 4 copies. In this case, double counting will occur.
+>
diff --git a/docs/source_en/roadmap.md b/docs/note/source_en/roadmap.md
similarity index 96%
rename from docs/source_en/roadmap.md
rename to docs/note/source_en/roadmap.md
index 774456c99e9b0106487ef04508f71c9f527a6ea6..890ea9d6a426fd207ecc261d6c9eadfbfe9ba166 100644
--- a/docs/source_en/roadmap.md
+++ b/docs/note/source_en/roadmap.md
@@ -14,7 +14,7 @@
-
+
MindSpore's top priority plans in the year are displayed as follows. We will continuously adjust the priority based on user feedback.
diff --git a/docs/note/source_zh_cn/_static/logo_notebook.png b/docs/note/source_zh_cn/_static/logo_notebook.png
new file mode 100644
index 0000000000000000000000000000000000000000..18c2e29e4b73ee428f70253feffdd855fdf0c422
Binary files /dev/null and b/docs/note/source_zh_cn/_static/logo_notebook.png differ
diff --git a/docs/note/source_zh_cn/_static/logo_source.png b/docs/note/source_zh_cn/_static/logo_source.png
new file mode 100644
index 0000000000000000000000000000000000000000..880f2bc87172daf487654c0ba4f1657c672bd2b8
Binary files /dev/null and b/docs/note/source_zh_cn/_static/logo_source.png differ
diff --git a/docs/source_zh_cn/benchmark.md b/docs/note/source_zh_cn/benchmark.md
similarity index 81%
rename from docs/source_zh_cn/benchmark.md
rename to docs/note/source_zh_cn/benchmark.md
index ef06735f46f6673c99111035a22acb68433056fe..a80f100d43dd94b98ce9ac62d82ec176ab4db2cd 100644
--- a/docs/source_zh_cn/benchmark.md
+++ b/docs/note/source_zh_cn/benchmark.md
@@ -12,10 +12,10 @@
- [Wide & Deep (Host-Device混合计算模型并行)](#wide--deep-host-device混合计算模型并行)
-
-
-本文介绍MindSpore的基准性能。MindSpore网络定义可参考[Model Zoo](https://gitee.com/mindspore/mindspore/tree/master/model_zoo)。
+
+
+本文介绍MindSpore的基准性能。MindSpore网络定义可参考[Model Zoo](https://gitee.com/mindspore/mindspore/tree/r1.0/model_zoo)。
## 训练性能
@@ -32,12 +32,12 @@
### BERT
-| Network | Network Type | Dataset | MindSpore Version | Resource | Precision | Batch Size | Throughput | Speedup |
+| Network | Network Type | Dataset | MindSpore Version | Resource | Precision | Batch Size | Throughput | Speedup |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| BERT-Large | Attention | zhwiki | 0.5.0-beta | Ascend: 1 * Ascend 910 CPU：24 Cores | Mixed | 96 | 269 sentences/sec | - |
| | | | | Ascend: 8 * Ascend 910 CPU：192 Cores | Mixed | 96 | 2069 sentences/sec | 0.96 |
-1. 以上数据基于华为云AI开发平台ModelArts测试获得，其中网络包含24个隐藏层，句长为128个token，字典表包含21128个token。
+1. 以上数据基于华为云AI开发平台ModelArts测试获得，其中网络包含24个隐藏层，句长为128个token，字典表包含21128个token。
2. 业界其他开源框架数据可参考：[BERT For TensorFlow](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/LanguageModeling/BERT)。
### Wide & Deep (数据并行)
@@ -45,7 +45,7 @@
| Network | Network Type | Dataset | MindSpore Version | Resource | Precision | Batch Size | Throughput | Speedup |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Wide & Deep | Recommend | Criteo | 0.6.0-beta | Ascend: 1 * Ascend 910 CPU：24 Cores | Mixed | 16000 | 796892 samples/sec | - |
-| | | | | Ascend: 8 * Ascend 910 CPU：192 Cores | Mixed | 16000*8 | 4872849 samples/sec | 0.76 |
+| | | | | Ascend: 8 \* Ascend 910 CPU：192 Cores | Mixed | 16000*8 | 4872849 samples/sec | 0.76 |
1. 以上数据基于Atlas 800测试获得，且网络模型为数据并行。
2. 业界其他开源框架数据可参考：[Wide & Deep For TensorFlow](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/Recommendation/WideAndDeep)。
@@ -55,9 +55,9 @@
| Network | Network Type | Dataset | MindSpore Version | Resource | Precision | Batch Size | Throughput | Speedup |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Wide & Deep | Recommend | Criteo | 0.6.0-beta | Ascend: 1 * Ascend 910 CPU：24 Cores | Mixed | 8000 | 68715 samples/sec | - |
-| | | | | Ascend: 8 * Ascend 910 CPU：192 Cores | Mixed | 8000*8 | 283830 samples/sec | 0.51 |
-| | | | | Ascend: 16 * Ascend 910 CPU：384 Cores | Mixed | 8000*16 | 377848 samples/sec | 0.34 |
-| | | | | Ascend: 32 * Ascend 910 CPU：768 Cores | Mixed | 8000*32 | 433423 samples/sec | 0.20 |
+| | | | | Ascend: 8 \* Ascend 910 CPU：192 Cores | Mixed | 8000*8 | 283830 samples/sec | 0.51 |
+| | | | | Ascend: 16 \* Ascend 910 CPU：384 Cores | Mixed | 8000*16 | 377848 samples/sec | 0.34 |
+| | | | | Ascend: 32 \* Ascend 910 CPU：768 Cores | Mixed | 8000*32 | 433423 samples/sec | 0.20 |
1. 以上数据基于Atlas 800测试获得，且网络模型为模型并行。
2. 业界其他开源框架数据可参考：[Wide & Deep For TensorFlow](https://github.com/NVIDIA/DeepLearningExamples/tree/master/TensorFlow/Recommendation/WideAndDeep)。
diff --git a/docs/source_zh_cn/community.rst b/docs/note/source_zh_cn/community.rst
similarity index 85%
rename from docs/source_zh_cn/community.rst
rename to docs/note/source_zh_cn/community.rst
index 04ffbb4cde98b2fdb3646e754840ef042f019292..97682d4ed419fc477d6c0fcd87988151d3cd8e6d 100644
--- a/docs/source_zh_cn/community.rst
+++ b/docs/note/source_zh_cn/community.rst
@@ -9,4 +9,4 @@
贡献文档
-----------
-如何贡献文档，请参见链接 https://gitee.com/mindspore/docs/blob/master/CONTRIBUTING_DOC.md 。
\ No newline at end of file
+如何贡献文档，请参见链接 https://gitee.com/mindspore/docs/blob/master/CONTRIBUTING_DOC_CN.md 。
\ No newline at end of file
diff --git a/lite/docs/source_zh_cn/conf.py b/docs/note/source_zh_cn/conf.py
similarity index 92%
rename from lite/docs/source_zh_cn/conf.py
rename to docs/note/source_zh_cn/conf.py
index dd8e0482bb14ee1ec4242dcd8e550cbb12eb0712..95d7701759707ab95a3c199cd8a22e2e2cc1194d 100644
--- a/lite/docs/source_zh_cn/conf.py
+++ b/docs/note/source_zh_cn/conf.py
@@ -15,9 +15,9 @@ import os
# -- Project information -----------------------------------------------------
-project = 'MindSpore Lite'
-copyright = '2020, MindSpore Lite'
-author = 'MindSpore Lite'
+project = 'MindSpore'
+copyright = '2020, MindSpore'
+author = 'MindSpore'
# The full version, including alpha/beta/rc tags
release = 'master'
@@ -48,8 +48,6 @@ exclude_patterns = []
pygments_style = 'sphinx'
-autodoc_inherit_docstrings = False
-
# -- Options for HTML output -------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
@@ -59,4 +57,6 @@ html_theme = 'sphinx_rtd_theme'
html_search_language = 'zh'
+html_search_options = {'dict': '../../resource/jieba.txt'}
+
html_static_path = ['_static']
\ No newline at end of file
diff --git a/docs/source_zh_cn/constraints_on_network_construction.md b/docs/note/source_zh_cn/constraints_on_network_construction.md
similarity index 55%
rename from docs/source_zh_cn/constraints_on_network_construction.md
rename to docs/note/source_zh_cn/constraints_on_network_construction.md
index 8b352b2625d65ebdb811e75a84caddc9a71f0b78..b55e0319a93ceabecca351f763444dd22f1fb117 100644
--- a/docs/source_zh_cn/constraints_on_network_construction.md
+++ b/docs/note/source_zh_cn/constraints_on_network_construction.md
@@ -25,24 +25,29 @@
-
+
## 概述
+
MindSpore完成从用户源码到计算图的编译，用户源码基于Python语法编写，当前MindSpore支持将普通函数或者继承自nn.Cell的实例转换生成计算图，暂不支持将任意Python源码转换成计算图，所以对于用户源码支持的写法有所限制，主要包括语法约束和网络定义约束两方面。随着MindSpore的演进，这些约束可能会发生变化。
## 语法约束
+
### 支持的Python数据类型
-* Number：包括`int`、`float`、`bool`，不支持复数类型。
-* String
-* List：当前只支持append方法；List的更新会拷贝生成新的List。
-* Tuple
-* Dictionary：当前`key`只支持String类型
+
+- Number：包括`int`、`float`、`bool`，不支持复数类型。
+- String
+- List：当前只支持append方法；List的更新会拷贝生成新的List。
+- Tuple
+- Dictionary：当前`key`只支持String类型
+
### MindSpore扩展数据类型
-* Tensor：Tensor变量必须是已定义实例。
+
+- Tensor：Tensor变量必须是已定义实例。
### 表达式类型
-| 操作名 | 具体操作
+| 操作名 | 具体操作
| :----------- |:--------
| 一元操作符 |`+`、`-`、`not`，其中`+`操作符只支持标量。
| 数学表达式 |`+`、`-`、`*`、`/`、`%`、`**`、`//`
@@ -81,10 +86,11 @@
| `isinstance` | 使用原则与Python一致，但第二个入参只能是mindspore定义的类型。
### 函数参数
-* 参数默认值：目前不支持默认值设为`Tensor`类型数据，支持`int`、`float`、`bool`、`None`、`str`、`tuple`、`list`、`dict`类型数据。
-* 可变参数：支持带可变参数网络的推理和训练。
-* 键值对参数：目前不支持带键值对参数的函数求反向。
-* 可变键值对参数：目前不支持带可变键值对的函数求反向。
+
+- 参数默认值：目前不支持默认值设为`Tensor`类型数据，支持`int`、`float`、`bool`、`None`、`str`、`tuple`、`list`、`dict`类型数据。
+- 可变参数：支持带可变参数网络的推理和训练。
+- 键值对参数：目前不支持带键值对参数的函数求反向。
+- 可变键值对参数：目前不支持带可变键值对的函数求反向。
### 操作符
@@ -104,51 +110,52 @@
索引操作包含`tuple`和`Tensor`的索引操作。下面重点介绍一下`Tensor`的索引取值和赋值操作，取值以`tensor_x[index]`为例，赋值以`tensor_x[index] = u`为例进行详细说明。其中tensor_x是一个`Tensor`，对其进行切片操作；index表示索引，u表示赋予的值，可以是`scalar`或者`Tensor(size=1)`。索引类型如下：
- 切片索引：index为`slice`
- - 取值：`tensor_x[start:stop:step]`，其中Slice(start:stop:step)与Python的语法相同，这里不再赘述。
- - 赋值：`tensor_x[start:stop:step]=u`。
+ - 取值：`tensor_x[start:stop:step]`，其中Slice(start:stop:step)与Python的语法相同，这里不再赘述。
+ - 赋值：`tensor_x[start:stop:step]=u`。
- Ellipsis索引：index为`ellipsis`
- - 取值：`tensor_x[...]`。
- - 赋值：`tensor_x[...]=u`。
+ - 取值：`tensor_x[...]`。
+ - 赋值：`tensor_x[...]=u`。
- 布尔常量索引：index为`True`，index为`False`暂不支持。
- - 取值：`tensor_x[True]`。
- - 赋值：暂不支持。
+ - 取值：`tensor_x[True]`。
+ - 赋值：暂不支持。
- Tensor索引：index为`Tensor`
- - 取值：`tensor_x[index]`，`index`必须是`int32`、`int64`类型的`Tensor`，元素取值范围在`[0, tensor_x.shape[0])`。
- - 赋值：`tensor_x[index]=U`。
- - `tensor_x`的数据类型必须是下面一种： `float16`，`float32`，`int8`，`uint8`。
- - `index`必须是`int32`类型的`Tensor`，元素取值范围在`[0, tensor_x.shape[0])`。
- - `U`可以是`Number`，`Tensor`，只包含`Number`的`Tuple`，只包含`Tensor`的`Tuple`。
- - 单个`Number`和`Tuple`里的每个`Number`必须与`tensor_x`的数据类型属于同一类，即
+ - 取值：`tensor_x[index]`，`index`必须是`int32`、`int64`类型的`Tensor`，元素取值范围在`[0, tensor_x.shape[0])`。
+ - 赋值：`tensor_x[index]=U`。
+ - `tensor_x`的数据类型必须是下面一种： `float16`，`float32`，`int8`，`uint8`。
+ - `index`必须是`int32`类型的`Tensor`，元素取值范围在`[0, tensor_x.shape[0])`。
+ - `U`可以是`Number`，`Tensor`，只包含`Number`的`Tuple`，只包含`Tensor`的`Tuple`。
+ - 单个`Number`和`Tuple`里的每个`Number`必须与`tensor_x`的数据类型属于同一类，即
当`tensor_x`的数据类型是`uint8`或者`int8`时，`Number`类型应该是`int`；
当`tensor_x`的数据类型是`float16`或者`float32`时，`Number`类型应该是`float`。
- - 单个`Tensor`和`Tuple`里的每个`Tensor`必须与`tensor_x`的数据类型一致，
+ - 单个`Tensor`和`Tuple`里的每个`Tensor`必须与`tensor_x`的数据类型一致，
单个`Tensor`时，其`shape`需等于或者可广播为`index.shape + tensor_x.shape[1:]`。
- - 包含`Number`的`Tuple`需满足下面条件：
+ - 包含`Number`的`Tuple`需满足下面条件：
`len(Tuple) = (index.shape + tensor_x.shape[1:])[-1]`。
- - 包含`Tensor`的`Tuple`需满足下面条件：
+ - 包含`Tensor`的`Tuple`需满足下面条件：
每个`Tensor`的`shape`一样；
`(len(Tuple),) + Tensor.shape`等于或者可广播为`index.shape + tensor_x.shape[1:]`。
- None常量索引：index为`None`
- - 取值：`tensor_x[None]`，结果与numpy保持一致。
- - 赋值：暂不支持。
+ - 取值：`tensor_x[None]`，结果与numpy保持一致。
+ - 赋值：暂不支持。
- tuple索引：index为`tuple`
- - tuple元素为slice:
- - 取值：例如`tensor_x[::, :4, 3:0:-1]`。
- - 赋值：例如`tensor_x[::, :4, 3:0:-1]=u`。
- - tuple元素为Number:
- - 取值：例如`tensor_x[2,1]`。
- - 赋值：例如`tensor_x[1,4]=u`。
- - tuple元素为slice和ellipsis混合情况:
- - 取值：例如`tensor_x[..., ::, 1:]`
- - 赋值：例如`tensor_x[..., ::, 1:]=u`
- - 其他情况暂不支持
+ - tuple元素为slice:
+ - 取值：例如`tensor_x[::, :4, 3:0:-1]`。
+ - 赋值：例如`tensor_x[::, :4, 3:0:-1]=u`。
+ - tuple元素为Number:
+ - 取值：例如`tensor_x[2,1]`。
+ - 赋值：例如`tensor_x[1,4]=u`。
+ - tuple元素为slice和ellipsis混合情况:
+ - 取值：例如`tensor_x[..., ::, 1:]`
+ - 赋值：例如`tensor_x[..., ::, 1:]=u`
+ - 其他情况暂不支持
tuple和list类型的索引取值操作，需要重点介绍一下元素类型为`nn.Cell`的tuple或list的索引取值操作，该操作目前在Graph模式下仅GPU后端支持运行，其语法格式形如`layers[index](*inputs)`，具体示例代码如下：
+
```python
class Net(nn.Cell):
def __init__(self):
@@ -161,13 +168,16 @@ tuple和list类型的索引取值操作，需要重点介绍一下元素类型
x = self.layers[index](x)
return x
```
+
同时该语法有以下几个约束：
-* 只支持元素类型为`nn.Cell`的tuple或list的索引取值操作。
-* 索引值index的类型为`int32`的Tensor标量，取值范围为`[-n, n)`, 其中`n`为tuple的size，支持的tuple的size的最大值为1000。
-* tuple中的每个Cell元素的Construct函数的输入数据的数目，类型和shape要求相同，且Construct函数运行后输出的数据的数目，类型和shape也要求相同。
-* tuple中的每个Cell元素，需要在tuple定义之前完成定义。
-* 该语法不支持做为if、while、for等控制流的运行分支，如果控制流的控制条件为常量除外。举例说明：
- - 支持的写法：
+
+- 只支持元素类型为`nn.Cell`的tuple或list的索引取值操作。
+- 索引值index的类型为`int32`的Tensor标量，取值范围为`[-n, n)`, 其中`n`为tuple的size，支持的tuple的size的最大值为1000。
+- tuple中的每个Cell元素的Construct函数的输入数据的数目，类型和shape要求相同，且Construct函数运行后输出的数据的数目，类型和shape也要求相同。
+- tuple中的每个Cell元素，需要在tuple定义之前完成定义。
+- 该语法不支持做为if、while、for等控制流的运行分支，如果控制流的控制条件为常量除外。举例说明：
+ - 支持的写法：
+
```python
class Net(nn.Cell):
def __init__(self, flag=True):
@@ -182,7 +192,9 @@ tuple和list类型的索引取值操作，需要重点介绍一下元素类型
x = self.layers[index](x)
return x
```
- - 不支持的写法：
+
+ - 不支持的写法：
+
```python
class Net(nn.Cell):
def __init__(self):
@@ -201,64 +213,99 @@ tuple也支持切片取值操作, 但不支持切片类型为Tensor类型，支
### 不支持的语法
-目前在网络构造函数里面暂不支持以下语法：
+目前在网络构造函数里面暂不支持以下语法：
`raise`、 `yield`、 `async for`、 `with`、 `async with`、 `assert`、 `import`、 `await`。
## 网络定义约束
### 整网实例类型
-* 带[@ms_function](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.html#mindspore.ms_function)装饰器的普通Python函数。
-* 继承自[nn.Cell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Cell)的Cell子类。
+
+- 带[@ms_function](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.html#mindspore.ms_function)装饰器的普通Python函数。
+- 继承自[nn.Cell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Cell)的Cell子类。
### 网络输入类型
-* 整网的训练数据输入参数只能是Tensor类型。
-* 生成的ANF图里面不能包含这几种常量节点：字符串类型常量、带有Tuple嵌套的常量、带有List嵌套的常量。
+
+- 整网的训练数据输入参数只能是Tensor类型。
+- 生成的ANF图里面不能包含这几种常量节点：字符串类型常量、带有Tuple嵌套的常量、带有List嵌套的常量。
### 网络图优化
+
在ME前端图优化过程中，会将DataClass类型、Dictionary、List、键值对操作转换为Tuple相关操作。
### 网络构造组件
| 类别 | 内容
| :----------- |:--------
-| `Cell`实例 |[mindspore/nn/*](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html)、自定义[Cell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Cell)。
+| `Cell`实例 |[mindspore/nn/*](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html)、自定义[Cell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Cell)。
| `Cell`实例的成员函数 | Cell的construct中可以调用其他类成员函数。
| 函数 | 自定义Python函数、前文中列举的系统函数。
| dataclass实例 | 使用@dataclass装饰的类。
-| Primitive算子 |[mindspore/ops/operations/*](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html)
-| Composite算子 |[mindspore/ops/composite/*](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.composite.html)
-| constexpr生成算子 |使用[@constexpr](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.html#mindspore.ops.constexpr)生成的值计算算子。
-
+| Primitive算子 |[mindspore/ops/operations/*](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html)
+| Composite算子 |[mindspore/ops/composite/*](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html)
+| constexpr生成算子 |使用[@constexpr](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.constexpr)生成的值计算算子。
### 其他约束
-整网construct函数输入的参数以及使用ms_function装饰器修饰的函数的参数在图编译过程中会进行泛化，不能作为常量输入传给算子使用。所以，在图模式下，限制入口网络的参数只能是Tensor，如下例所示：
-* 错误的写法如下：
+
+1. 整网`construct`函数输入的参数以及使用`ms_function`装饰器修饰的函数的参数在图编译过程中会进行泛化，不能作为常量输入传给算子使用。所以，在图模式下，限制入口网络的参数只能是`Tensor`，如下例所示：
+
+ - 错误的写法如下：
+
+ ```python
+ class ExpandDimsTest(Cell):
+ def __init__(self):
+ super(ExpandDimsTest, self).__init__()
+ self.expandDims = ops.ExpandDims()
+
+ def construct(self, input_x, input_axis):
+ return self.expandDims(input_x, input_axis)
+ expand_dim = ExpandDimsTest()
+ input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
+ expand_dim(input_x, 0)
+ ```
+
+ 在示例中，`ExpandDimsTest`是一个只有单算子的网络，网络的输入有`input_x`和`input_axis`两个。因为`ExpandDims`算子的第二个输入需要是常量，这是因为在图编译过程中推导`ExpandDims`算子输出维度的时候需要用到，而`input_axis`作为网络参数输入会泛化成变量，无法确定其值，从而无法推导算子的输出维度导致图编译失败。所以在图编译阶段需要值推导的输入都应该是常量输入。在API中，这类算子需要常量输入的参数会进行说明，标注"constant input is needed"。
+
+ - 正确的写法是在construct函数里面对算子的常量输入直接填入需要的值或者是一个类的成员变量，如下：
+
+ ```python
+ class ExpandDimsTest(Cell):
+ def __init__(self, axis):
+ super(ExpandDimsTest, self).__init__()
+ self.expandDims = ops.ExpandDims()
+ self.axis = axis
+
+ def construct(self, input_x):
+ return self.expandDims(input_x, self.axis)
+ axis = 0
+ expand_dim = ExpandDimsTest(axis)
+ input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
+ expand_dim(input_x)
+ ```
+
+2. 不允许修改网络的非`Parameter`类型数据成员。示例如下：
+
```python
- class ExpandDimsTest(Cell):
+ class Net(Cell):
def __init__(self):
- super(ExpandDimsTest, self).__init__()
- self.expandDims = P.ExpandDims()
-
- def construct(self, input_x, input_axis):
- return self.expandDims(input_x, input_axis)
- expand_dim = ExpandDimsTest()
- input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
- expand_dim(input_x, 0)
+ super(Net, self).__init__()
+ self.num = 2
+ self.par = Parameter(Tensor(np.ones((2, 3, 4))), name="par")
+
+ def construct(self, x, y):
+ return x + y
```
- 在示例中，ExpandDimsTest是一个只有单算子的网络，网络的输入有input_x和input_axis两个。因为ExpandDims算子的第二个输入需要是常量，这是因为在图编译过程中推导ExpandDims算子输出维度的时候需要用到，而input_axis作为网络参数输入会泛化成变量，无法确定其值，从而无法推导算子的输出维度导致图编译失败。所以在图编译阶段需要值推导的输入都应该是常量输入。在API中，这类算子需要常量输入的参数会进行说明，标注"constant input is needed"。
-* 正确的写法是在construct函数里面对算子的常量输入直接填入需要的值或者是一个类的成员变量，如下：
+ 上面所定义的网络里，`self.num`不是一个`Parameter`，不允许被修改，而`self.par`是一个`Parameter`，可以被修改。
+
+3. 当`construct`函数里，使用未定义的类成员时，不会像Python解释器那样抛出`AttributeError`，而是作为`None`处理。示例如下：
+
```python
- class ExpandDimsTest(Cell):
- def __init__(self, axis):
- super(ExpandDimsTest, self).__init__()
- self.expandDims = P.ExpandDims()
- self.axis = axis
-
- def construct(self, input_x):
- return self.expandDims(input_x, self.axis)
- axis = 0
- expand_dim = ExpandDimsTest(axis)
- input_x = Tensor(np.random.randn(2,2,2,2).astype(np.float32))
- expand_dim(input_x)
+ class Net(Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+
+ def construct(self, x):
+ return x + self.y
```
+
+ 上面所定义的网络里，`construct`里使用了并未定义的类成员`self.y`，此时会将`self.y`作为`None`处理。
diff --git a/docs/note/source_zh_cn/design/mindarmour.rst b/docs/note/source_zh_cn/design/mindarmour.rst
new file mode 100644
index 0000000000000000000000000000000000000000..d35c7aeab99e43e46d1baa9d57e9fb8fc3398c9c
--- /dev/null
+++ b/docs/note/source_zh_cn/design/mindarmour.rst
@@ -0,0 +1,8 @@
+MindArmour设计
+==============
+
+.. toctree::
+ :maxdepth: 1
+
+ mindarmour/differential_privacy_design
+ mindarmour/fuzzer_design
\ No newline at end of file
diff --git a/docs/source_zh_cn/design/mindarmour/differential_privacy_design.md b/docs/note/source_zh_cn/design/mindarmour/differential_privacy_design.md
similarity index 70%
rename from docs/source_zh_cn/design/mindarmour/differential_privacy_design.md
rename to docs/note/source_zh_cn/design/mindarmour/differential_privacy_design.md
index 276219655693f4c3424f23906cde901cd465217a..0ed09c88d7b74cc7e8a9afbca8abfa81f664942e 100644
--- a/docs/source_zh_cn/design/mindarmour/differential_privacy_design.md
+++ b/docs/note/source_zh_cn/design/mindarmour/differential_privacy_design.md
@@ -1,70 +1,68 @@
-# 差分隐私
-
-`Linux` `Ascend` `模型开发` `模型调优` `框架开发` `企业` `高级` `贡献者`
-
-
-
-- [差分隐私](#差分隐私)
- - [总体设计](#总体设计)
- - [差分隐私优化器](#差分隐私优化器)
- - [差分隐私的噪声机制](#差分隐私的噪声机制)
- - [Monitor](#monitor)
- - [代码实现](#代码实现)
- - [参考文献](#参考文献)
-
-
-
-
-
-## 总体设计
-
-MindArmour的Differential-Privacy模块实现了差分隐私训练的能力。模型的训练主要由构建训练数据集、计算损失、计算梯度以及更新模型参数等过程组成，目前MindArmour的差分隐私训练主要着力于计算梯度的过程，通过相应的算法对梯度进行裁剪、加噪等处理，从而保护用户数据隐私。
-
-
-
-
+
+## 总体设计
+
+MindArmour的Differential-Privacy模块实现了差分隐私训练的能力。模型的训练主要由构建训练数据集、计算损失、计算梯度以及更新模型参数等过程组成，目前MindArmour的差分隐私训练主要着力于计算梯度的过程，通过相应的算法对梯度进行裁剪、加噪等处理，从而保护用户数据隐私。
+
+
+
+
-
-## 背景
-
-不同于[传统程序的Fuzz安全测试](https://zhuanlan.zhihu.com/p/43432370)，MindArmour针对深度神经网络，提供AI模型安全测试模块Fuzzer。根据神经网络的特点，引入神经元覆盖率[1]的概念，作为Fuzz的测试指导，引导Fuzz朝神经元覆盖率增加的方向生成样本，让输入能够激活更多的神经元，神经元值的分布范围更广，以充分测试DNN，探索不同类型的模型输出结果、模型错误行为。
-
-## Fuzzer设计图
-
-AI模型安全测试设计图如下。
-
-
-
-在用户接口层，需要用户提供原始数据集`DataSet`、被测试模型`Model`和配置Fuzzer参数`Fuzzer configuration`。Fuzzer模块对模型和数据进行Fuzz测试后，返回安全评估报告`Security Report`。
-
-Fuzzer架构主要包括三个模块：
-
-1. Natural Threat/Adversarial Example Generator（数据变异模块）：
-
- 随机选择变异方法对种子数据变异生成多个变种。支持多种样本的变异策略， 包括：
-
- - 图像仿射变换方法如：平移、旋转、缩放、错切。
- - 基于图像像素值变化的方法如：改变对比度、亮度、模糊、加噪。
- - 基于对抗攻击的白盒、黑盒对抗样本生成方法，如FGSM、PGD、MDIIM。
-
-2. Fuzzer moduler（变异指导模块）:
-
- 对变异生成的数据进行fuzz测试，观察神经元覆盖率的变化情况，如果生成的数据使得神经元覆盖率增加，则加入变异的种子队列，用于下一轮的数据变异。目前支持的神经元覆盖率指标包括KMNC、NBC、SNAC[2]。
-
-3. Evaluation（评估模块）：
-
- 评估Fuzzer效果，生成数据的质量，变异方法的强度。支持3个类型5种指标，包括通用评价指标：accuracy，神经元覆盖率指标：kmnc， nbc，snac，对抗攻击评价指标：attack_success_rate。
-
-## Fuzzer流程
-
-
-
-具体的Fuzzer流程如下：
-
-1. 根据策略从种子队列中选择一个种子A。
-2. 随机选择变异策略，对种子A进行变异，生成多个变种数据A1，A2...
-3. 用目标模型对变种A1，A2...进行预测，如果变种使得目标模型预测错误，则改变种进入Failed tests。
-4. 若目标模型对于变种的预测结果是正确的，用神经元覆盖率指标进行分析。
-5. 如果变种使得覆盖率增加，那么将该变种放入种子队列，用于下一轮变异。
-
-通过多轮循环，我们获得一系列变异数据Fuzzed Tests，并进一步分析，从多个角度给出安全报告。可以用于深入分析神经网络模型的缺陷，从而针对这些缺陷，进行模型增强等，改善提升模型的通用性、鲁棒性。
-
-## 代码实现
-
-1. [fuzzing.py](https://gitee.com/mindspore/mindarmour/blob/master/mindarmour/fuzz_testing/fuzzing.py)：Fuzzer总体流程。
-2. [model_coverage_metrics.py](https://gitee.com/mindspore/mindarmour/blob/master/mindarmour/fuzz_testing/model_coverage_metrics.py)：神经元覆盖率指标，包括KMNC，NBC，SNAC。
-3. [image_transform.py](https://gitee.com/mindspore/mindarmour/blob/master/mindarmour/fuzz_testing/image_transform.py)：图像变异方法，包括基于像素值的变化方法和仿射变化方法。
-4. [adversarial attacks](https://gitee.com/mindspore/mindarmour/tree/master/mindarmour/adv_robustness/attacks)：对抗样本攻击方法，包含多种黑盒、白盒攻击方法。
-
-## 参考文献
-
-[1] Pei K, Cao Y, Yang J, et al. Deepxplore: Automated whitebox testing of deep learning systems[C]//Proceedings of the 26th Symposium on Operating Systems Principles. ACM, 2017: 1-18.
-
-[2]Ma L, Juefei-Xu F, Zhang F, et al. Deepgauge: Multi-granularity testing criteria for deep learning systems[C]//Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering. ACM, 2018: 120-131.
+# AI模型安全测试
+
+`Linux` `Ascend` `GPU` `CPU` `数据准备` `模型开发` `模型训练` `模型调优` `企业` `高级`
+
+
+- [AI模型安全测试](#ai模型安全测试)
+ - [背景](#背景)
+ - [Fuzz Testing设计图](#fuzz-testing设计图)
+ - [Fuzz Testing流程](#fuzz-testing流程)
+ - [代码实现](#代码实现)
+ - [参考文献](#参考文献)
+
+
+
+
+
+## 背景
+
+不同于[传统程序的Fuzz安全测试](https://zhuanlan.zhihu.com/p/43432370)，MindArmour针对深度神经网络，提供AI模型安全测试模块fuzz_testing。根据神经网络的特点，引入神经元覆盖率[1]的概念，作为Fuzz的测试指导，引导Fuzz朝神经元覆盖率增加的方向生成样本，让输入能够激活更多的神经元，神经元值的分布范围更广，以充分测试DNN，探索不同类型的模型输出结果、模型错误行为。
+
+## Fuzz Testing设计图
+
+AI模型安全测试设计图如下。
+
+
+
+在用户接口层，需要用户提供原始数据集`DataSet`、被测试模型`Model`和配置Fuzzer参数`Fuzzer configuration`。Fuzzer模块对模型和数据进行Fuzz测试后，返回安全评估报告`Security Report`。
+
+Fuzz Testing架构主要包括三个模块：
+
+1. Natural Threat/Adversarial Example Generator（数据变异模块）：
+
+ 随机选择变异方法对种子数据变异生成多个变种。支持多种样本的变异策略， 包括：
+
+ - 图像仿射变换方法如：平移、旋转、缩放、错切。
+ - 基于图像像素值变化的方法如：改变对比度、亮度、模糊、加噪。
+ - 基于对抗攻击的白盒、黑盒对抗样本生成方法，如FGSM、PGD、MDIIM。
+
+2. Fuzzer moduler（变异指导模块）:
+
+ 对变异生成的数据进行fuzz测试，观察神经元覆盖率的变化情况，如果生成的数据使得神经元覆盖率增加，则加入变异的种子队列，用于下一轮的数据变异。目前支持的神经元覆盖率指标包括KMNC、NBC、SNAC[2]。
+
+3. Evaluation（评估模块）：
+
+ 评估Fuzz Testing的效果，生成数据的质量，变异方法的强度。支持3个类型5种指标，包括通用评价指标：accuracy，神经元覆盖率指标：kmnc， nbc，snac，对抗攻击评价指标：attack_success_rate。
+
+## Fuzz Testing流程
+
+
+
+具体的Fuzz Testing流程如下：
+
+1. 根据策略从种子队列中选择一个种子A。
+2. 随机选择变异策略，对种子A进行变异，生成多个变种数据A1，A2...
+3. 用目标模型对变种A1，A2...进行预测，如果变种的语意与种子保持一致，则进入Fuzzed Tests。
+4. 若目标模型对于变种的预测结果是正确的，用神经元覆盖率指标进行分析。
+5. 如果变种使得覆盖率增加，那么将该变种放入种子队列，用于下一轮变异。
+
+通过多轮循环，我们获得一系列变异数据Fuzzed Tests，并进一步分析，从多个角度给出安全报告。可以用于深入分析神经网络模型的缺陷，从而针对这些缺陷，进行模型增强等，改善提升模型的通用性、鲁棒性。
+
+## 代码实现
+
+1. [fuzzing.py](https://gitee.com/mindspore/mindarmour/blob/r1.0/mindarmour/fuzz_testing/fuzzing.py)：Fuzzer总体流程。
+2. [model_coverage_metrics.py](https://gitee.com/mindspore/mindarmour/blob/r1.0/mindarmour/fuzz_testing/model_coverage_metrics.py)：神经元覆盖率指标，包括KMNC，NBC，SNAC。
+3. [image_transform.py](https://gitee.com/mindspore/mindarmour/blob/r1.0/mindarmour/fuzz_testing/image_transform.py)：图像变异方法，包括基于像素值的变化方法和仿射变化方法。
+4. [adversarial attacks](https://gitee.com/mindspore/mindarmour/tree/r1.0/mindarmour/adv_robustness/attacks)：对抗样本攻击方法，包含多种黑盒、白盒攻击方法。
+
+## 参考文献
+
+[1] Pei K, Cao Y, Yang J, et al. Deepxplore: Automated whitebox testing of deep learning systems[C]//Proceedings of the 26th Symposium on Operating Systems Principles. ACM, 2017: 1-18.
+
+[2]Ma L, Juefei-Xu F, Zhang F, et al. Deepgauge: Multi-granularity testing criteria for deep learning systems[C]//Proceedings of the 33rd ACM/IEEE International Conference on Automated Software Engineering. ACM, 2018: 120-131.
diff --git a/docs/source_zh_cn/design/mindarmour/images/dp_arch.png b/docs/note/source_zh_cn/design/mindarmour/images/dp_arch.png
similarity index 100%
rename from docs/source_zh_cn/design/mindarmour/images/dp_arch.png
rename to docs/note/source_zh_cn/design/mindarmour/images/dp_arch.png
diff --git a/docs/note/source_zh_cn/design/mindarmour/images/fuzz_architecture.png b/docs/note/source_zh_cn/design/mindarmour/images/fuzz_architecture.png
new file mode 100644
index 0000000000000000000000000000000000000000..d4e8b89bd9a9f4844c59790f5b2114d1d477f927
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindarmour/images/fuzz_architecture.png differ
diff --git a/docs/note/source_zh_cn/design/mindarmour/images/fuzz_process.png b/docs/note/source_zh_cn/design/mindarmour/images/fuzz_process.png
new file mode 100644
index 0000000000000000000000000000000000000000..2e04347f7cfb0819562578a6be1e91b5cc7ce9d5
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindarmour/images/fuzz_process.png differ
diff --git a/docs/note/source_zh_cn/design/mindinsight.rst b/docs/note/source_zh_cn/design/mindinsight.rst
new file mode 100644
index 0000000000000000000000000000000000000000..242655ac2beb1953dfddcdcbb5a40d182a2721a0
--- /dev/null
+++ b/docs/note/source_zh_cn/design/mindinsight.rst
@@ -0,0 +1,9 @@
+MindInsight设计
+===============
+
+.. toctree::
+ :maxdepth: 1
+
+ mindinsight/training_visual_design
+ mindinsight/graph_visual_design
+ mindinsight/tensor_visual_design
\ No newline at end of file
diff --git a/docs/source_zh_cn/design/mindinsight/graph_visual_design.md b/docs/note/source_zh_cn/design/mindinsight/graph_visual_design.md
similarity index 83%
rename from docs/source_zh_cn/design/mindinsight/graph_visual_design.md
rename to docs/note/source_zh_cn/design/mindinsight/graph_visual_design.md
index f84aa65eba740aff307dc5fa61435489335cc051..4521e4658655b10dce088ff82224f0f091bca571 100644
--- a/docs/source_zh_cn/design/mindinsight/graph_visual_design.md
+++ b/docs/note/source_zh_cn/design/mindinsight/graph_visual_design.md
@@ -15,15 +15,15 @@
-
+
## 特性背景
计算图可视的功能，主要协助开发者在下面这些场景中使用。
- - 开发者在编写深度学习神经网络的代码时，可以使用计算图的功能查看神经网络中算子的数据流走向，以及模型结构。
- - 计算图还可以方便开发者查看指定节点的输入和输出节点，以及所查找的节点的属性信息。
- - 开发者在调试网络时，可以通过可视化的计算图，轻易跟踪数据，包括数据维度、类型的变更等。
+- 开发者在编写深度学习神经网络的代码时，可以使用计算图的功能查看神经网络中算子的数据流走向，以及模型结构。
+- 计算图还可以方便开发者查看指定节点的输入和输出节点，以及所查找的节点的属性信息。
+- 开发者在调试网络时，可以通过可视化的计算图，轻易跟踪数据，包括数据维度、类型的变更等。
## 总体设计
@@ -71,4 +71,4 @@ RESTful API接口是MindInsight前后端进行数据交互的接口。
#### 文件接口设计
MindSpore与MindInsight之间的数据交互，采用[protobuf](https://developers.google.cn/protocol-buffers/docs/pythontutorial?hl=zh-cn)定义数据格式。
-[summary.proto文件](https://gitee.com/mindspore/mindinsight/blob/master/mindinsight/datavisual/proto_files/mindinsight_summary.proto)为总入口，计算图的消息对象定义为 `GraphProto`。`GraphProto`的详细定义可以参考[anf_ir.proto文件](https://gitee.com/mindspore/mindinsight/blob/master/mindinsight/datavisual/proto_files/mindinsight_anf_ir.proto)。
+[summary.proto文件](https://gitee.com/mindspore/mindinsight/blob/r1.0/mindinsight/datavisual/proto_files/mindinsight_summary.proto)为总入口，计算图的消息对象定义为 `GraphProto`。`GraphProto`的详细定义可以参考[anf_ir.proto文件](https://gitee.com/mindspore/mindinsight/blob/r1.0/mindinsight/datavisual/proto_files/mindinsight_anf_ir.proto)。
diff --git a/docs/source_zh_cn/design/mindinsight/images/graph_visual_class_design.png b/docs/note/source_zh_cn/design/mindinsight/images/graph_visual_class_design.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/graph_visual_class_design.png
rename to docs/note/source_zh_cn/design/mindinsight/images/graph_visual_class_design.png
diff --git a/tutorials/source_zh_cn/advanced_use/images/graph.png b/docs/note/source_zh_cn/design/mindinsight/images/graph_visual_main.png
similarity index 100%
rename from tutorials/source_zh_cn/advanced_use/images/graph.png
rename to docs/note/source_zh_cn/design/mindinsight/images/graph_visual_main.png
diff --git a/tutorials/source_zh_cn/advanced_use/images/graph_sidebar.png b/docs/note/source_zh_cn/design/mindinsight/images/graph_visual_right_side.png
similarity index 100%
rename from tutorials/source_zh_cn/advanced_use/images/graph_sidebar.png
rename to docs/note/source_zh_cn/design/mindinsight/images/graph_visual_right_side.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/tensor_histogram.png b/docs/note/source_zh_cn/design/mindinsight/images/tensor_histogram.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/tensor_histogram.png
rename to docs/note/source_zh_cn/design/mindinsight/images/tensor_histogram.png
diff --git a/tutorials/source_zh_cn/advanced_use/images/tensor_table.png b/docs/note/source_zh_cn/design/mindinsight/images/tensor_table.png
similarity index 100%
rename from tutorials/source_zh_cn/advanced_use/images/tensor_table.png
rename to docs/note/source_zh_cn/design/mindinsight/images/tensor_table.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/training_visualization_architecture.png b/docs/note/source_zh_cn/design/mindinsight/images/training_visualization_architecture.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/training_visualization_architecture.png
rename to docs/note/source_zh_cn/design/mindinsight/images/training_visualization_architecture.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/training_visualization_data_flow.png b/docs/note/source_zh_cn/design/mindinsight/images/training_visualization_data_flow.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/training_visualization_data_flow.png
rename to docs/note/source_zh_cn/design/mindinsight/images/training_visualization_data_flow.png
diff --git a/docs/source_zh_cn/design/mindinsight/images/training_visualization_data_model.png b/docs/note/source_zh_cn/design/mindinsight/images/training_visualization_data_model.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/training_visualization_data_model.png
rename to docs/note/source_zh_cn/design/mindinsight/images/training_visualization_data_model.png
diff --git a/docs/source_zh_cn/design/mindinsight/tensor_visual_design.md b/docs/note/source_zh_cn/design/mindinsight/tensor_visual_design.md
similarity index 83%
rename from docs/source_zh_cn/design/mindinsight/tensor_visual_design.md
rename to docs/note/source_zh_cn/design/mindinsight/tensor_visual_design.md
index e3af486df552ed81c7f4e4b6fab8bf680c0b2687..75955438b594f0c5b26268bb4610bfaa58e059dd 100644
--- a/docs/source_zh_cn/design/mindinsight/tensor_visual_design.md
+++ b/docs/note/source_zh_cn/design/mindinsight/tensor_visual_design.md
@@ -14,7 +14,7 @@
-
+
## 特性背景
@@ -44,7 +44,7 @@ Tensor可视支持1-N维的Tensor以表格或直方图的形式展示，对于0
图1将用户所记录的张量以表格的形式展示，包含以下功能：
-- 表格中白色方框显示当前展示的是哪个维度下的张量数据，其中冒号`:`表示当前维度的所有值，可以在方框输入对应的索引（和Python的索引含义一致，支持负值）或者`:`来查询特定维度的张量数据。
+- 表格中白色方框显示当前展示的是哪个维度下的张量数据，其中冒号`:`表示当前维度索引范围，和Python索引含义基本一致，不指定具体索引表示当前维度所有值，`2:5`表示索引2到5（不包括5）的值，可以在方框输入对应的索引或者含有`:`的索引范围来查询特定维度的张量数据。
- 拖拽表格下方的空心圆圈可以查询特定步骤的张量数据。
@@ -55,12 +55,13 @@ Tensor可视支持1-N维的Tensor以表格或直方图的形式展示，对于0
### 接口设计
-在张量可视中，主要有文件接口和RESTful API接口，其中文件接口为[summary.proto](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/utils/summary.proto)文件，是MindInsight和MindSpore进行数据对接的接口。 RESTful API接口是MindInsight前后端进行数据交互的接口，是内部接口。
+在张量可视中，主要有文件接口和RESTful API接口，其中文件接口为[summary.proto](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/utils/summary.proto)文件，是MindInsight和MindSpore进行数据对接的接口。 RESTful API接口是MindInsight前后端进行数据交互的接口，是内部接口。
#### 文件接口设计
`summary.proto`文件为总入口，其中张量的数据（TensorProto）存放在Summary的Value中，如下所示：
-```
+
+```protobuf
{
message Summary {
message Image {
@@ -69,7 +70,7 @@ Tensor可视支持1-N维的Tensor以表格或直方图的形式展示，对于0
required int32 width = 2;
...
}
-
+
message Histogram {
message bucket{
// Counting number of values fallen in [left, left + width).
@@ -78,7 +79,7 @@ Tensor可视支持1-N维的Tensor以表格或直方图的形式展示，对于0
required double width = 2;
required int64 count = 3;
}
-
+
repeated bucket buckets = 1;
...
}
@@ -86,7 +87,7 @@ Tensor可视支持1-N维的Tensor以表格或直方图的形式展示，对于0
message Value {
// Tag name for the data.
required string tag = 1;
-
+
// Value associated with the tag.
oneof value {
float scalar_value = 3;
@@ -100,4 +101,5 @@ Tensor可视支持1-N维的Tensor以表格或直方图的形式展示，对于0
repeated Value value = 1;
}
```
-而TensorProto的定义在[anf_ir.proto](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/utils/anf_ir.proto)文件中。
\ No newline at end of file
+
+而TensorProto的定义在[anf_ir.proto](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/utils/anf_ir.proto)文件中。
diff --git a/docs/source_zh_cn/design/mindinsight/training_visual_design.md b/docs/note/source_zh_cn/design/mindinsight/training_visual_design.md
similarity index 92%
rename from docs/source_zh_cn/design/mindinsight/training_visual_design.md
rename to docs/note/source_zh_cn/design/mindinsight/training_visual_design.md
index 8e5c5071aba3bba71fdabd771556c60bab14e13f..0bf0ef0d7a1a5eefb1b85142dabc82ec1664428a 100644
--- a/docs/source_zh_cn/design/mindinsight/training_visual_design.md
+++ b/docs/note/source_zh_cn/design/mindinsight/training_visual_design.md
@@ -18,7 +18,7 @@
-
+
[MindInsight](https://gitee.com/mindspore/mindinsight)是MindSpore的可视化调试调优组件。通过MindInsight可以完成训练可视、性能调优、精度调优等任务。
@@ -40,11 +40,11 @@
训练信息收集API包括：
-- 基于summary算子的训练信息收集API。这部分API主要包括4个summary算子，即用于记录标量数据的ScalarSummary算子，用于记录图片数据的ImageSummary算子，用于记录参数分布图（直方图）数据的HistogramSummary算子和用于记录张量数据的TensorSummary算子。请访问[算子支持列表](https://www.mindspore.cn/docs/zh-CN/master/operator_list.html)以获取关于这些算子的信息。
+- 基于summary算子的训练信息收集API。这部分API主要包括4个summary算子，即用于记录标量数据的ScalarSummary算子，用于记录图片数据的ImageSummary算子，用于记录参数分布图（直方图）数据的HistogramSummary算子和用于记录张量数据的TensorSummary算子。请访问[算子支持列表](https://www.mindspore.cn/doc/note/zh-CN/r1.0/operator_list.html)以获取关于这些算子的信息。
-- 基于Python API的训练信息收集API。通过[SummaryRecord.add_value](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.train.html#mindspore.train.summary.SummaryRecord.add_value)方法，可以在Python代码中完成训练信息的收集。
+- 基于Python API的训练信息收集API。通过[SummaryRecord.add_value](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.train.html#mindspore.train.summary.SummaryRecord.add_value)方法，可以在Python代码中完成训练信息的收集。
-- 易用的训练信息收集callback。通过[SummaryCollector](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.train.html#mindspore.train.callback.SummaryCollector)这一callback可以方便地收集常用训练信息到训练日志中。
+- 易用的训练信息收集callback。通过[SummaryCollector](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.train.html#mindspore.train.callback.SummaryCollector)这一callback可以方便地收集常用训练信息到训练日志中。
训练信息持久化模块主要包括用于管理缓存的summary_record模块和用于并行处理数据、写入文件的write_pool模块。训练信息持久化后，存储在训练日志文件（summary文件中）。
diff --git a/docs/note/source_zh_cn/design/mindspore.rst b/docs/note/source_zh_cn/design/mindspore.rst
new file mode 100644
index 0000000000000000000000000000000000000000..ccb0c24c4482c3a28bda79d7d2da62b337788208
--- /dev/null
+++ b/docs/note/source_zh_cn/design/mindspore.rst
@@ -0,0 +1,10 @@
+MindSpore设计
+==============
+
+.. toctree::
+ :maxdepth: 1
+
+ mindspore/mindir
+ mindspore/distributed_training_design
+ mindspore/profiler_design
+
diff --git a/docs/source_zh_cn/architecture.md b/docs/note/source_zh_cn/design/mindspore/architecture.md
similarity index 44%
rename from docs/source_zh_cn/architecture.md
rename to docs/note/source_zh_cn/design/mindspore/architecture.md
index 091f5ca131fe9784d785c39b330241330181c23a..a5e2ddbf010e3e953b6c017e9d6f478df6663ce9 100644
--- a/docs/source_zh_cn/architecture.md
+++ b/docs/note/source_zh_cn/design/mindspore/architecture.md
@@ -1,25 +1,25 @@
-# 总体架构
+# MindSpore总体架构
`Linux` `Windows` `Ascend` `GPU` `CPU` `端侧` `模型开发` `模型调优` `框架开发` `中级` `高级` `贡献者`
-
+
MindSpore框架架构总体分为MindSpore前端表示层、MindSpore计算图引擎和MindSpore后端运行时三层。
-- MindSpore前端表示层（Mind Expression，简称ME）
+- MindSpore前端表示层（MindExpression，简称ME）
该部分包含Python API、MindSpore IR（Intermediate representation，简称IR）、计算图高级别优化（Graph High Level Optimization，简称GHLO）三部分。
- - Python API向用户提供统一的模型训练、推理、导出接口，以及统一的数据处理、增强、格式转换接口。
- - GHLO包含硬件无关的优化（如死代码消除等）、自动并行和自动微分等功能。
- - MindSpore IR提供统一的中间表示，MindSpore基于此IR进行pass优化。
+ - Python API向用户提供统一的模型训练、推理、导出接口，以及统一的数据处理、增强、格式转换接口。
+ - GHLO包含硬件无关的优化（如死代码消除等）、自动并行和自动微分等功能。
+ - MindSpore IR提供统一的中间表示，MindSpore基于此IR进行pass优化。
-- MindSpore计算图引擎（Graph Engine，简称GE）
+- MindSpore计算图引擎（GraphEngine，简称GE）
该部分包含计算图低级别优化（Graph Low Level Optimization，简称GLLO）、图执行。
- - GLLO包含硬件相关的优化，以及算子融合、Buffer融合等软硬件结合相关的深度优化。
- - 图执行提供离线图执行、分布式训练所需要的通信接口等功能。
+ - GLLO包含硬件相关的优化，以及算子融合、Buffer融合等软硬件结合相关的深度优化。
+ - 图执行提供离线图执行、分布式训练所需要的通信接口等功能。
- MindSpore后端运行时
diff --git a/lite/docs/source_zh_cn/architecture.md b/docs/note/source_zh_cn/design/mindspore/architecture_lite.md
similarity index 73%
rename from lite/docs/source_zh_cn/architecture.md
rename to docs/note/source_zh_cn/design/mindspore/architecture_lite.md
index ce86fa9829a184306cde335d74d06a70117c6c63..361af443080b0df3d51e09270da66f2bd3f5a7a5 100644
--- a/lite/docs/source_zh_cn/architecture.md
+++ b/docs/note/source_zh_cn/design/mindspore/architecture_lite.md
@@ -1,10 +1,12 @@
-# 总体架构
+# MindSpore Lite总体架构
-
+`Linux` `Windows` `端侧` `推理应用` `中级` `高级` `贡献者`
+
+
MindSpore Lite框架的总体架构如下所示：
-
+
- **前端（Frontend）：** 负责模型生成，用户可以通过模型构建接口构建模型，将第三方模型和MindSpore训练的模型转换为MindSpore Lite模型，其中第三方模型包括TensorFlow Lite、Caffe 1.0和ONNX模型。
@@ -12,9 +14,8 @@ MindSpore Lite框架的总体架构如下所示：
- **Backend：** 基于IR进行图优化，包括GHLO、GLLO和量化三部分。其中，GHLO负责和硬件无关的优化，如算子融合、常量折叠等；GLLO负责与硬件相关的优化；量化Quantizer支持权重量化、激活值量化等训练后量化手段。
-- **Runtime：** 智能终端的推理运行时，其中session负责会话管理，提供对外接口；线程池和并行原语负责图执行使用的线程池管理，内存分配负责图执行中各个算子的内存复用，算子库提供CPU和GPU算子。
+- **Runtime：** 智能终端的推理运行时，其中session负责会话管理，提供对外接口；线程池和并行原语负责图执行使用的线程池管理，内存分配负责图执行中各个算子的内存复用，算子库提供CPU和GPU算子。
- **Micro：** IoT设备的运行时，包括模型生成.c文件、线程池、内存复用和算子库。
-其中，Runtime和Micro共享底层的算子库、内存分配、线程池、并行原语等基础设施层。
-
+其中，Runtime和Micro共享底层的算子库、内存分配、线程池、并行原语等基础设施层。
diff --git a/docs/source_zh_cn/design/mindspore/distributed_training_design.md b/docs/note/source_zh_cn/design/mindspore/distributed_training_design.md
similarity index 67%
rename from docs/source_zh_cn/design/mindspore/distributed_training_design.md
rename to docs/note/source_zh_cn/design/mindspore/distributed_training_design.md
index 3a73eb8ff66d49500707f959e32d87fb926bf85c..19a4d40a86a6804f556be15f2c9aa21939da1062 100644
--- a/docs/source_zh_cn/design/mindspore/distributed_training_design.md
+++ b/docs/note/source_zh_cn/design/mindspore/distributed_training_design.md
@@ -18,13 +18,12 @@
-
+
## 背景
随着深度学习的快步发展，为了提升神经网络的精度和泛化能力，数据集和参数量都在呈指数级向上攀升。分布式并行训练成为一种解决超大规模网络性能瓶颈的发展趋势。MindSpore支持了当前主流的分布式训练范式并开发了一套自动混合并行解决方案。本篇设计文档将会集中介绍几种并行训练方式的设计原理，同时指导用户进行自定义开发。
-
## 概念
### 集合通信
@@ -47,19 +46,19 @@
每次开始进行并行训练前，通过调用`mindspore.communication.init`接口初始化通信资源，并自动创建全局通信组`WORLD_COMM_GROUP`。
-2. 数据分发
+2. 数据分发（Data distribution）
数据并行的核心在于将数据集在样本维度拆分并下发到不同的卡上。在`mindspore.dataset`模块提供的所有数据集加载接口中都有`num_shards`和`shard_id`两个参数，它们用于将数据集拆分为多份并循环采样的方式，采集`batch`大小的数据到各自的卡上，当出现数据量不足的情况时将会从头开始采样。
3. 网络构图
- 数据并行网络的书写方式与单机网络没有差别，这是因为在正反向传播过程中各卡的模型间是独立执行的，只是保持了相同的网络结构。唯一需要特别注意的是为了保证各卡间训练同步，相应的网络参数初始化值应当是一致的，这里建议通过`numpy.random.seed`在每张卡上设置相同的随机数种子达到模型广播的目的。
+ 数据并行网络的书写方式与单机网络没有差别，这是因为在正反向传播（Forward propogation & Backword Propogation）过程中各卡的模型间是独立执行的，只是保持了相同的网络结构。唯一需要特别注意的是为了保证各卡间训练同步，相应的网络参数初始化值应当是一致的，这里建议通过`numpy.random.seed`在每张卡上设置相同的随机数种子达到模型广播的目的。
-4. 梯度聚合
+4. 梯度聚合（Gradient aggregation）
数据并行理论上应该实现和单机一致的训练效果，为了保证计算逻辑的一致性，在梯度计算完成后插入`AllReduce`算子实现各卡间的梯度聚合操作。这里我们设置了`mean`开关，用户可以选择是否要对求和后的梯度值进行求平均操作，也可以将其视为超参项，打开开关等价于学习率倍数缩小。
-5. 参数更新
+5. 参数更新（Parameter update）
因为引入了梯度聚合操作，所以各卡的模型会以相同的梯度值一起进入参数更新步骤。因此MindSpore实现的是一种同步数据并行训练方式。理论上最终每卡训练出来的模型是相同的，如果网络中含有在样本维度的归约类型操作，网络的输出可能会有所差别，这是由数据并行的切分性质决定的。
@@ -67,13 +66,12 @@
1. 集合通信
- - [management.py](https://gitee.com/mindspore/mindspore/blob/master/mindspore/communication/management.py): 这个文件中涵盖了集合通信过程中常用的`helper`函数接口，例如获取集群数量和卡的序号等。当在Ascend芯片上执行时，框架会加载环境上的`libhccl.so`库文件，通过它来完成从Python层到底层的通信接口调用。
- - [comm_ops.py](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ops/operations/comm_ops.py): MindSpore将支持的集合通信操作都封装为算子的形式放在这个文件下，包括`AllReduce`、`AllGather`、`ReduceScatter`和`Broadcast`等。`PrimitiveWithInfer`中除了定义算子所需属性外，还包括构图过程中输入到输出的`shape`和`dtype`推导。
+ - [management.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/communication/management.py): 这个文件中涵盖了集合通信过程中常用的`helper`函数接口，例如获取集群数量和卡的序号等。当在Ascend芯片上执行时，框架会加载环境上的`libhccl.so`库文件，通过它来完成从Python层到底层的通信接口调用。
+ - [comm_ops.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ops/operations/comm_ops.py): MindSpore将支持的集合通信操作都封装为算子的形式放在这个文件下，包括`AllReduce`、`AllGather`、`ReduceScatter`和`Broadcast`等。`PrimitiveWithInfer`中除了定义算子所需属性外，还包括构图过程中输入到输出的`shape`和`dtype`推导。
2. 梯度聚合
- - [grad_reducer.py](https://gitee.com/mindspore/mindspore/blob/master/mindspore/nn/wrap/grad_reducer.py): 这个文件实现了梯度聚合的过程。对入参`grads`用`HyperMap`展开后插入`AllReduce`算子，这里采用的是全局通信组，用户也可以根据自己网络的需求仿照这个模块进行自定义开发。MindSpore中单机和分布式执行共用一套网络封装接口，在`Cell`内部通过`ParallelMode`来区分是否要对梯度做聚合操作，网络封装接口建议参考`TrainOneStepCell`代码实现。
-
+ - [grad_reducer.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/nn/wrap/grad_reducer.py): 这个文件实现了梯度聚合的过程。对入参`grads`用`HyperMap`展开后插入`AllReduce`算子，这里采用的是全局通信组，用户也可以根据自己网络的需求仿照这个模块进行自定义开发。MindSpore中单机和分布式执行共用一套网络封装接口，在`Cell`内部通过`ParallelMode`来区分是否要对梯度做聚合操作，网络封装接口建议参考`TrainOneStepCell`代码实现。
## 自动并行
@@ -90,34 +88,31 @@
为了得到张量的排布模型，每个算子都具有切分策略（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`组成，分别表示设备矩阵形状、张量形状、设备和张量维度间的映射关系。分布式算子会进一步根据张量排布模型判断是否要在图中中插入额外的计算、通信操作，以保证算子运算逻辑正确。
2. 张量排布变换
当前一个算子的输出张量模型和后一个算子的输入张量模型不一致时，就需要引入计算、通信操作的方式实现张量排布间的变化。自动并行流程引入了张量重排布算法（Tensor Redistribution），可以推导得到任意排布的张量间通信转换方式。下面三个样例表示公式`Z=(X×W)×V`的并行计算过程， 即两个二维矩阵乘操作，体现了不同并行方式间如何转换。
在样例一中，第一个数据并行矩阵乘的输出在行方向上存在切分，而第二个模型并行矩阵乘的输入需要全量张量，框架将会自动插入`AllGather`算子实现排布变换。
-
+
-
+
在样例二中，第一个模型并行矩阵乘的输出在列方向上存在切分，而第二个数据并行矩阵乘的输入在行方向上存在切分，框架将会自动插入等价于集合通信中`AlltoAll`操作的通信算子实现排布变换。
-
在样例三中，第一个混合并行矩阵乘的输出切分方式和第二个混合并行矩阵乘的输入切分方式一致，所以不需要引入重排布变换。但由于第二个矩阵乘操作中，两个输入的相关维度存在切分，所以需要插入`AllReduce`算子保证运算正确性。
-
综上，1、2两点是自动并行实现的基础，总体来说这种分布式表达打破了数据并行和模型并行的边界，轻松实现混合并行。从脚本层面上，用户仅需构造单机网络，即可表达并行算法逻辑，框架将自动实现对整图切分。
3. 切分策略搜索算法
当用户熟悉了算子的切分表达，并手动对算子配置切分策略，这就是`SEMI_AUTO_PARALLEL`半自动并行模式。这种方式对手动调优有帮助，但还是具有一定的调试难度，用户需要掌握并行原理，并根据网络结构、集群拓扑等计算分析得到高性能的并行方案。为了进一步帮助用户加速并行网络训练过程，在半自动并行模式的基础上，`AUTO_PARALLEL`自动并行模式引入了并行切分策略自动搜索的特性。自动并行围绕硬件平台构建相应的代价函数模型（Cost Model），计算出一定数据量、一定算子在不同切分策略下的计算开销（Computation Cost），内存开销（Memory Cost）及通信开销（Communication Cost）。然后通过动态规划算法（Dynamic Programming）或者递归规划算法（Recursive Programming），以单卡的内存上限为约束条件，高效地搜索出性能较优的切分策略。
-
- 策略搜索这一步骤代替了用户手动指定模型切分，在短时间内可以得到较高性能的切分方案，极大降低了并行训练的使用门槛。
+ 策略搜索这一步骤代替了用户手动指定模型切分，在短时间内可以得到较高性能的切分方案，极大降低了并行训练的使用门槛。
4. 分布式自动微分
@@ -126,21 +121,19 @@
### 自动并行代码
1. 张量排布模型
- - [tensor_layout](https://gitee.com/mindspore/mindspore/tree/master/mindspore/ccsrc/frontend/parallel/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_`。
+ - [tensor_layout](https://gitee.com/mindspore/mindspore/tree/r1.0/mindspore/ccsrc/frontend/parallel/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_`。
2. 分布式算子
- - [ops_info](https://gitee.com/mindspore/mindspore/tree/master/mindspore/ccsrc/frontend/parallel/ops_info)：这个目录下包含了分布式算子的具体实现。在`operator_info.h`中定义了分布式算子实现的基类`OperatorInfo`，开发一个分布式算子需要继承于这个基类并显式实现相关的虚函数。其中`InferTensorInfo`，`InferTensorMap`和`InferDevMatrixShape`函数定义了推导该算子输入、输出张量排布模型的算法。`InferForwardCommunication`，`InferMirrorOps`等函数定义了切分该算子需要插入的额外计算、通信操作。`CheckStrategy`和`GenerateStrategies`函数定义了算子切分策略校验和生成。根据切分策略`SetCostUnderStrategy`将会产生该策略下分布式算子的并行开销值`operator_cost_`。
+ - [ops_info](https://gitee.com/mindspore/mindspore/tree/r1.0/mindspore/ccsrc/frontend/parallel/ops_info)：这个目录下包含了分布式算子的具体实现。在`operator_info.h`中定义了分布式算子实现的基类`OperatorInfo`，开发一个分布式算子需要继承于这个基类并显式实现相关的虚函数。其中`InferTensorInfo`，`InferTensorMap`和`InferDevMatrixShape`函数定义了推导该算子输入、输出张量排布模型的算法。`InferForwardCommunication`，`InferMirrorOps`等函数定义了切分该算子需要插入的额外计算、通信操作。`CheckStrategy`和`GenerateStrategies`函数定义了算子切分策略校验和生成。根据切分策略`SetCostUnderStrategy`将会产生该策略下分布式算子的并行开销值`operator_cost_`。
3. 策略搜索算法
- - [auto_parallel](https://gitee.com/mindspore/mindspore/tree/master/mindspore/ccsrc/frontend/parallel/auto_parallel)：这个目录下实现了切分策略搜索的算法。`graph_costmodel.h`定义了构图信息，其中每个点表示一个算子`OperatorInfo`，有向边`edge_costmodel.h`表示算子的输入输出关系及重排布的代价。`operator_costmodel.h`中定义了每个算子的代价模型，包括计算代价、通信代价和内存代价。`dp_algorithm_costmodel.h`主要描述了动态规划算法的主要流程，由一系列图操作组成。在`costmodel.h`中定义了cost和图操作的数据结构。
+ - [auto_parallel](https://gitee.com/mindspore/mindspore/tree/r1.0/mindspore/ccsrc/frontend/parallel/auto_parallel)：这个目录下实现了切分策略搜索的算法。`graph_costmodel.h`定义了构图信息，其中每个点表示一个算子`OperatorInfo`，有向边`edge_costmodel.h`表示算子的输入输出关系及重排布的代价。`operator_costmodel.h`中定义了每个算子的代价模型，包括计算代价、通信代价和内存代价。`dp_algorithm_costmodel.h`主要描述了动态规划算法的主要流程，由一系列图操作组成。在`costmodel.h`中定义了cost和图操作的数据结构。
4. 设备管理
- - [device_manager.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/frontend/parallel/device_manager.h)：这个文件实现了集群设备通信组的创建及管理。其中设备矩阵模型由`device_matrix.h`定义，通信域由`group_manager.h`管理。
+ - [device_manager.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/frontend/parallel/device_manager.h)：这个文件实现了集群设备通信组的创建及管理。其中设备矩阵模型由`device_matrix.h`定义，通信域由`group_manager.h`管理。
5. 整图切分
- - [step_auto_parallel.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/frontend/parallel/step_auto_parallel.h), [step_parallel.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/frontend/parallel/step_parallel.h)：这两个文件包含了自动并行流程的核心实现。首先由`step_auto_parallel.h`调用策略搜索流程并产生分布式算子的`OperatorInfo`，然后在`step_parallel.h`中处理算子切分和张量重排布等流程，对单机计算图进行分布式改造。
-
+ - [step_auto_parallel.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/frontend/parallel/step_auto_parallel.h), [step_parallel.h](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ccsrc/frontend/parallel/step_parallel.h)：这两个文件包含了自动并行流程的核心实现。首先由`step_auto_parallel.h`调用策略搜索流程并产生分布式算子的`OperatorInfo`，然后在`step_parallel.h`中处理算子切分和张量重排布等流程，对单机计算图进行分布式改造。
6. 通信算子反向
- - [grad_comm_ops.py](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ops/_grad/grad_comm_ops.py): 这个文件定义了`AllReduce`和`AllGather`等通信算子的反向操作。
-
+ - [grad_comm_ops.py](https://gitee.com/mindspore/mindspore/blob/r1.0/mindspore/ops/_grad/grad_comm_ops.py): 这个文件定义了`AllReduce`和`AllGather`等通信算子的反向操作。
diff --git a/lite/docs/source_zh_cn/images/MindSpore-Lite-architecture.png b/docs/note/source_zh_cn/design/mindspore/images/MindSpore-Lite-architecture.png
similarity index 100%
rename from lite/docs/source_zh_cn/images/MindSpore-Lite-architecture.png
rename to docs/note/source_zh_cn/design/mindspore/images/MindSpore-Lite-architecture.png
diff --git a/docs/note/source_zh_cn/design/mindspore/images/analyser_class_profiler.png b/docs/note/source_zh_cn/design/mindspore/images/analyser_class_profiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..3f785786eb8652e8d1cfc09795e48895da80eef9
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/analyser_class_profiler.png differ
diff --git a/docs/source_zh_cn/images/architecture.eddx b/docs/note/source_zh_cn/design/mindspore/images/architecture.eddx
similarity index 100%
rename from docs/source_zh_cn/images/architecture.eddx
rename to docs/note/source_zh_cn/design/mindspore/images/architecture.eddx
diff --git a/docs/source_zh_cn/images/architecture.png b/docs/note/source_zh_cn/design/mindspore/images/architecture.png
similarity index 100%
rename from docs/source_zh_cn/images/architecture.png
rename to docs/note/source_zh_cn/design/mindspore/images/architecture.png
diff --git a/docs/note/source_zh_cn/design/mindspore/images/auto_parallel.png b/docs/note/source_zh_cn/design/mindspore/images/auto_parallel.png
new file mode 100644
index 0000000000000000000000000000000000000000..800b3b2536c739dcc48a1e46b5f65fc327e4ce8d
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/auto_parallel.png differ
diff --git a/docs/source_zh_cn/design/mindinsight/images/context_profiler.png b/docs/note/source_zh_cn/design/mindspore/images/context_profiler.png
similarity index 100%
rename from docs/source_zh_cn/design/mindinsight/images/context_profiler.png
rename to docs/note/source_zh_cn/design/mindspore/images/context_profiler.png
diff --git a/docs/note/source_zh_cn/design/mindspore/images/data_parallel.png b/docs/note/source_zh_cn/design/mindspore/images/data_parallel.png
new file mode 100644
index 0000000000000000000000000000000000000000..a92c82aa64615b398e83b9bc2cf0aa2c5db9f904
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/data_parallel.png differ
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/cf.dot b/docs/note/source_zh_cn/design/mindspore/images/ir/cf.dot
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/cf.dot
rename to docs/note/source_zh_cn/design/mindspore/images/ir/cf.dot
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/cf.png b/docs/note/source_zh_cn/design/mindspore/images/ir/cf.png
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/cf.png
rename to docs/note/source_zh_cn/design/mindspore/images/ir/cf.png
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/closure.dot b/docs/note/source_zh_cn/design/mindspore/images/ir/closure.dot
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/closure.dot
rename to docs/note/source_zh_cn/design/mindspore/images/ir/closure.dot
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/closure.png b/docs/note/source_zh_cn/design/mindspore/images/ir/closure.png
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/closure.png
rename to docs/note/source_zh_cn/design/mindspore/images/ir/closure.png
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/hof.dot b/docs/note/source_zh_cn/design/mindspore/images/ir/hof.dot
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/hof.dot
rename to docs/note/source_zh_cn/design/mindspore/images/ir/hof.dot
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/hof.png b/docs/note/source_zh_cn/design/mindspore/images/ir/hof.png
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/hof.png
rename to docs/note/source_zh_cn/design/mindspore/images/ir/hof.png
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/ir.dot b/docs/note/source_zh_cn/design/mindspore/images/ir/ir.dot
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/ir.dot
rename to docs/note/source_zh_cn/design/mindspore/images/ir/ir.dot
diff --git a/docs/source_zh_cn/design/mindspore/images/ir/ir.png b/docs/note/source_zh_cn/design/mindspore/images/ir/ir.png
similarity index 100%
rename from docs/source_zh_cn/design/mindspore/images/ir/ir.png
rename to docs/note/source_zh_cn/design/mindspore/images/ir/ir.png
diff --git a/docs/note/source_zh_cn/design/mindspore/images/module_profiler.png b/docs/note/source_zh_cn/design/mindspore/images/module_profiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..f30582b53e046a37e5d97450b148d4e665ba174d
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/module_profiler.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/operator_split.png b/docs/note/source_zh_cn/design/mindspore/images/operator_split.png
new file mode 100644
index 0000000000000000000000000000000000000000..4063170990c6816884361f195db5851cfbdf932e
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/operator_split.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/parser_module_profiler.png b/docs/note/source_zh_cn/design/mindspore/images/parser_module_profiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..8ef3c927013517e341fbe44c7f96f0be05536b80
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/parser_module_profiler.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/proposer_class_profiler.png b/docs/note/source_zh_cn/design/mindspore/images/proposer_class_profiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..3e2d4363e92821b05cafc330573c981a1ab99bbf
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/proposer_class_profiler.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/proposer_module_profiler.png b/docs/note/source_zh_cn/design/mindspore/images/proposer_module_profiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..909dd42c89715d49a11c35764d84aab231b91fb4
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/proposer_module_profiler.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution1.png b/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution1.png
new file mode 100644
index 0000000000000000000000000000000000000000..ed4d79416a0a07f8d75e738aa544d214834ae778
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution1.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution2.png b/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution2.png
new file mode 100644
index 0000000000000000000000000000000000000000..114f984c66ae578722dbcdbb59ab03c44dbcb097
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution2.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution3.png b/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution3.png
new file mode 100644
index 0000000000000000000000000000000000000000..dd66c9120615f50f2b3f60cfe139954cb4adf307
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/tensor_redistribution3.png differ
diff --git a/docs/note/source_zh_cn/design/mindspore/images/time_order_profiler.png b/docs/note/source_zh_cn/design/mindspore/images/time_order_profiler.png
new file mode 100644
index 0000000000000000000000000000000000000000..35eef99934ce9d743ebe0294e18ff0b5ea40abab
Binary files /dev/null and b/docs/note/source_zh_cn/design/mindspore/images/time_order_profiler.png differ
diff --git a/docs/source_zh_cn/design/mindspore/ir.md b/docs/note/source_zh_cn/design/mindspore/mindir.md
similarity index 91%
rename from docs/source_zh_cn/design/mindspore/ir.md
rename to docs/note/source_zh_cn/design/mindspore/mindir.md
index 77bc45014d5301fa6f76a9505ce38a491c09b9b4..cceb968c12657a1c6e51d0a13886add936222d69 100644
--- a/docs/source_zh_cn/design/mindspore/ir.md
+++ b/docs/note/source_zh_cn/design/mindspore/mindir.md
@@ -1,6 +1,6 @@
# MindSpore IR（MindIR）
-`Linux` `框架开发` `中级` `高级` `贡献者`
+`Linux` `Windows` `框架开发` `中级` `高级` `贡献者`
@@ -17,16 +17,19 @@
-
+
## 简介
+
中间表示（IR）是程序编译过程中介于源语言和目标语言之间的程序表示，以方便编译器进行程序分析和优化，因此IR的设计需要考虑从源语言到目标语言的转换难度，同时考虑程序分析和优化的易用性和性能。
MindIR是一种基于图表示的函数式IR，其最核心的目的是服务于自动微分变换。自动微分采用的是基于函数式编程框架的变换方法，因此IR采用了接近于ANF函数式的语义。此外，借鉴Sea of Nodes[1]和Thorin[2]的优秀设计，采用了一种基于显性依赖图的表示方式。
## 文法定义
+
ANF是函数式编程中常用且简洁的中间表示，其文法定义如下所示：
-```
+
+```text
-
-## 背景
-
-为了支持用户在MindSpore进行模型开发性能调试，需要提供易用的Profile工具，直观地展现网络模型各维度的性能信息，为用户提供易用、丰富的性能分析功能，帮助用户快速定位网络中性能问题。
-
-## Profiler架构设计
-这一章将介绍Profiler的架构设计，第一节从整体Profiler的角度出发介绍其上下文交互关系，第二节将打开Profiler内部，介绍模块层架结构以及模块划分，第三节将介绍模块间的交互调用关系。
-
-### 上下文
-
-Profiler是MindSpore调试调优工具的一部分，在整个使用过程中的上下文环境如下图所示：
-
-
-
-图1：上下文关系图
-
-如上图所示，Profiler与其他部分的交互包括：
-
-1. 在训练脚本中调用MindSpore的Profiler向MindSpore的ada通信模块发送启动收集性能数据的命令，最终由ada生成性能原始数据；
-
-2. MindSpore侧Profiler将在用户脚本中对原始数据进行解析，并在用户指定的文件夹下面生成中间数据结果；
-
-3. Mindinsight侧Profiler对接中间数据，提供可视化Profiler功能供用户使用。
-### 模块层级结构
-
-模块层级划分如下：
-
-
-
-图2：层级模块关系图
-
-
-如上图所示，各个模块功能介绍如下：
-1. ProfilerAPI是代码侧对用户提供的调用入口，为用户提供了性能收集启动接口以及分析接口；
-2. Controller是ProfilerAPI下层的模块，被ProfilerAPI中的启动接口调用，负责控制下方性能收集功能的启动停止，原始数据会被ada写入固定位置；
-3. Parser是性能原始数据解析模块，由于性能原始数据是在设备侧收集的信息，所以信息不能直接被用户所理解，该模块负责将信息进行解析、组合、转换，最终形成用户可理解、上层可分析的中间结果；
-4. Analyser获取下层Parser解析出的中间结果，负责对中间结果的封装、筛选、排序，最终按照信息分类，返回各个类别对应的信息，提供给上层的表现层Profiler API、RESTful使用；
-5. 通过RESTful调用后端Analyser提供的common API，获取目标数据，以RESTful接口对接前端。
-
-### 内部模块交互
-从用户角度，有两种使用形式API、RESTful，我们以API为例，阐述一个完整的内部模块交互流程：
-
-
-
-图3：模块交互图
-
-如上图所示，各个模块交互流程如下：
-
-1. ProfilerAPI会调用下层Controller的控制函数，控制下层收集模块进行收集，目前收集模块（ada）是以常驻进程的方式接受命令，并独立工作收集性能信息的；
-
-2. 用户在训练结束后会调用ProfilerAPI的分析接口；
-
-3. Profiler API分析接口首先使用Parser模块对性能数据进行解析，产生中间结果，再调用Aalayser进行中间结果分析，最终将各类信息返回至用户侧。
-
-## 子模块设计
-### ProfilerAPI和Controller
-
-#### ProfilerAPI和Controller模块说明
-ProfilerAPI为用户在训练脚本侧提供入口API，用户通过ProfilerAPI启动性能收集以及对性能数据进行分析。
-ProfilerAPI通过Controller下发命令，完成对ada启动的控制。
-
-#### ProfilerAPI和Controller模块设计
-ProfilerAPI模块，属于上层应用接口层，由训练脚本集成。功能分为两部分：
-
-- 训练前调用底层Controller接口，下发命令，启动profiling统计任务。
-
-- 训练完成后，调用底层Controller接口，下发命令，停止性能统计任务，再调用Analyser、Parser模块接口解析数据文件，生成算子性能统计、training trace统计等结果数据。
-
-
-Controller模块提供对上层接口，并调用底层性能收集模块接口，下发启动和停止性能收集的命令。
-
-最终生成的性能原始数据主要包含：
-
-- `hwts.log.data.45.dev.profiler_default_tag`文件：存储算子执行信息，包括task的开始/结束，stream id的信息等；
-- `DATA_PREPROCESS.dev.AICPU`文件：AI CPU算子的执行各阶段的执行时间信息；
-- `Framework.host.task_desc_info`文件：存储算子id与算子名称的对应关系，以及每个算子的输入输出信息；
-- `training_trace.46.dev.profiler_default_tag`文件：存储每个step的开始结束时刻，迭代间隙、迭代前向反向、迭代拖尾的时刻信息。
-
-### Parser
-#### Parser模块介绍
-Parser是原始性能数据解析模块，由于原始性能数据是在设备侧收集的信息，所以信息不能直接被用户所理解，该模块负责将信息进行解析、组合、转换，最终形成用户可理解、上层可分析的中间结果。
-#### Parser模块设计
-
-
-图4：Parser模块图
-
-如上图所示，Parser模块主要由HWTS Parser、AI CPU Parser、Framework Parser、Training Trace Parser组成，每个模块对应解析一种原始数据，通过解析原始数据得到用户能读懂的中间文件。
-
-- HWTS Parser：解析`hwts.log.data.45.dev.profiler_default_tag`文件，获得Device基于task的统计信息，如每个task的开始/结束，stream id等数据，用于算子执行时间的计算。
-- AI CPU Parser：解析`DATA_PREPROCESS.dev.AICPU`文件，获得AI CPU算子的执行各阶段的执行时间信息。
-- Framework Parser：解析`Framework.host.task_desc_info`文件，用于获取AI Core算子与task的对应关系，算子关键信息等内容。
-- Training Trace Parser：解析`training_trace.46.dev.profiler_default_tag`文件，用于分析训练各阶段的时间。
-
-### Analyser
-
-#### Analyser模块介绍
-分析器的作用是对解析阶段生成的中间结果，进行筛选、排序、查询、分页等相关操作。
-
-#### Analyser模块设计
-
-该模块负责解析Parser生成的中间文件，为上层数据分析提供通用接口，将分析后的数据返回给上层展示给用户，由于各种中间文件有一定的共同点，可以抽象出公共内容，所以Analyser类设计如下图所示：
-
-
-
-图5：Analyser类图
-
-如上图所示，针对期望查询的不同内容，实现多个Analyser，每个Analyser可以定义筛选、排序、分页条件。每个Analyser知道自己需要哪些中间文件来进行数据的合并、筛选、排序。Analyser与Parser是通过Parser生成的中间文件关联起来的，本身不存在函数调用的情况，这样对两个模块进行了解耦。
-
-针对算子信息的Analyser，目前存在两种：
-
-- 针对算子类型平均信息的筛选。
-- 针对每个算子详细平均信息的筛选，分别在两个Analyser中实现（AicoreTypeAnalyser、AicoreDetailAnalyser）。
-
-为了隐藏Analyser内部实现，方便调用，使用简单工厂模式，通过AnalyserFactory获取指定的Analyser。
-
-
-### Proposer
-#### Proposer模块介绍
-Proposer是Profiler性能优化建议模块，Proposer调用Analyser模块获取性能数据，通过调优规则对性能数据进行分析，输出调优建议由UI、API接口展示给用户。
-
-#### Proposer模块设计
-
-模块划分如下所示：
-
-
-
-图6：Proposer模块图
-
-模块设计如上图所示：
-
-- Proposer提供接口用于API、RESTful调用以获取优化建议。
-- Proposer调用Analyser接口，获取性能数据并根据优化规则，获得优化建议。
-- Proposer调用Analyser工厂获得Analyser对象。
-
-调用Analyser对象的query接口获取信息，包括：按时间排序TOP N的AICore、AICoreType、AICpu算子信息、traning trace各阶段的时间信息。
-
-模块类设计如下所示：
-
-
-
-图7：Proposer类图
-
-如上模块类图所示：
-
-- 各类型Proposer继承抽象类Proposer并实现analyze方法；
-- API、CLI通过调用工厂ProposerFactory获取Proposer，并调用Proposer.analyze函数获取各类型的Proposer分析的优化建议。
\ No newline at end of file
+# Profiler设计文档
+
+`Linux` `Ascend` `GPU` `模型开发` `模型调优` `框架开发` `中级` `高级` `贡献者`
+
+
+
+- [Profiler设计文档](#profiler设计文档)
+ - [背景](#背景)
+ - [Profiler框架设计](#profiler架构设计)
+ - [上下文](#上下文)
+ - [模块层级结构](#模块层级结构)
+ - [内部模块交互](#内部模块交互)
+ - [子模块设计](#准备训练脚本)
+ - [ProfilerAPI和Controller](#profiler-api-controller)
+ - [ProfilerAPI和Controller模块介绍](#profiler-api-controller模块介绍)
+ - [Analyser](#analyser)
+ - [Analyser模块介绍](#analyser模块介绍)
+ - [Analyser模块设计](#analyser模块设计)
+ - [Parser](#parser)
+ - [Parser模块介绍](#parser模块介绍)
+ - [Parser模块设计](#parser模块设计)
+ - [Proposer](#proposer)
+ - [Proposer模块介绍](#proposer模块介绍)
+ - [Proposer模块设计](#proposer模块设计)
+
+
+
+
+
+## 背景
+
+为了支持用户在MindSpore进行模型开发性能调试，需要提供易用的Profile工具，直观地展现网络模型各维度的性能信息，为用户提供易用、丰富的性能分析功能，帮助用户快速定位网络中性能问题。
+
+## Profiler架构设计
+
+这一章将介绍Profiler的架构设计，第一节从整体Profiler的角度出发介绍其上下文交互关系，第二节将打开Profiler内部，介绍模块层架结构以及模块划分，第三节将介绍模块间的交互调用关系。
+
+### 上下文
+
+Profiler是MindSpore调试调优工具的一部分，在整个使用过程中的上下文环境如下图所示：
+
+
+
+图1：上下文关系图
+
+如上图所示，Profiler与其他部分的交互包括：
+
+1. 在训练脚本中调用MindSpore的Profiler向MindSpore的ada通信模块发送启动收集性能数据的命令，最终由ada生成性能原始数据；
+
+2. MindSpore侧Profiler将在用户脚本中对原始数据进行解析，并在用户指定的文件夹下面生成中间数据结果；
+
+3. Mindinsight侧Profiler对接中间数据，提供可视化Profiler功能供用户使用。
+
+### 模块层级结构
+
+模块层级划分如下：
+
+
+
+图2：层级模块关系图
+
+如上图所示，各个模块功能介绍如下：
+
+1. ProfilerAPI是代码侧对用户提供的调用入口，为用户提供了性能收集启动接口以及分析接口；
+2. Controller是ProfilerAPI下层的模块，被ProfilerAPI中的启动接口调用，负责控制下方性能收集功能的启动停止，原始数据会被ada写入固定位置；
+3. Parser是性能原始数据解析模块，由于性能原始数据是在设备侧收集的信息，所以信息不能直接被用户所理解，该模块负责将信息进行解析、组合、转换，最终形成用户可理解、上层可分析的中间结果；
+4. Analyser获取下层Parser解析出的中间结果，负责对中间结果的封装、筛选、排序，最终按照信息分类，返回各个类别对应的信息，提供给上层的表现层Profiler API、RESTful使用；
+5. 通过RESTful调用后端Analyser提供的common API，获取目标数据，以RESTful接口对接前端。
+
+### 内部模块交互
+
+从用户角度，有两种使用形式API、RESTful，我们以API为例，阐述一个完整的内部模块交互流程：
+
+
+
+图3：模块交互图
+
+如上图所示，各个模块交互流程如下：
+
+1. ProfilerAPI会调用下层Controller的控制函数，控制下层收集模块进行收集，目前收集模块（ada）是以常驻进程的方式接受命令，并独立工作收集性能信息的；
+
+2. 用户在训练结束后会调用ProfilerAPI的分析接口；
+
+3. Profiler API分析接口首先使用Parser模块对性能数据进行解析，产生中间结果，再调用Aalayser进行中间结果分析，最终将各类信息返回至用户侧。
+
+## 子模块设计
+
+### ProfilerAPI和Controller
+
+#### ProfilerAPI和Controller模块说明
+
+ProfilerAPI为用户在训练脚本侧提供入口API，用户通过ProfilerAPI启动性能收集以及对性能数据进行分析。
+ProfilerAPI通过Controller下发命令，完成对ada启动的控制。
+
+#### ProfilerAPI和Controller模块设计
+
+ProfilerAPI模块，属于上层应用接口层，由训练脚本集成。功能分为两部分：
+
+- 训练前调用底层Controller接口，下发命令，启动profiling统计任务。
+
+- 训练完成后，调用底层Controller接口，下发命令，停止性能统计任务，再调用Analyser、Parser模块接口解析数据文件，生成算子性能统计、training trace统计等结果数据。
+
+Controller模块提供对上层接口，并调用底层性能收集模块接口，下发启动和停止性能收集的命令。
+
+最终生成的性能原始数据主要包含：
+
+- `hwts.log.data.45.dev.profiler_default_tag`文件：存储算子执行信息，包括task的开始/结束，stream id的信息等；
+- `DATA_PREPROCESS.dev.AICPU`文件：AI CPU算子的执行各阶段的执行时间信息；
+- `Framework.host.task_desc_info`文件：存储算子id与算子名称的对应关系，以及每个算子的输入输出信息；
+- `training_trace.46.dev.profiler_default_tag`文件：存储每个step的开始结束时刻，迭代间隙、迭代前向反向、迭代拖尾的时刻信息。
+
+### Parser
+
+#### Parser模块介绍
+
+Parser是原始性能数据解析模块，由于原始性能数据是在设备侧收集的信息，所以信息不能直接被用户所理解，该模块负责将信息进行解析、组合、转换，最终形成用户可理解、上层可分析的中间结果。
+
+#### Parser模块设计
+
+
+
+图4：Parser模块图
+
+如上图所示，Parser模块主要由HWTS Parser、AI CPU Parser、Framework Parser、Training Trace Parser组成，每个模块对应解析一种原始数据，通过解析原始数据得到用户能读懂的中间文件。
+
+- HWTS Parser：解析`hwts.log.data.45.dev.profiler_default_tag`文件，获得Device基于task的统计信息，如每个task的开始/结束，stream id等数据，用于算子执行时间的计算。
+- AI CPU Parser：解析`DATA_PREPROCESS.dev.AICPU`文件，获得AI CPU算子的执行各阶段的执行时间信息。
+- Framework Parser：解析`Framework.host.task_desc_info`文件，用于获取AI Core算子与task的对应关系，算子关键信息等内容。
+- Training Trace Parser：解析`training_trace.46.dev.profiler_default_tag`文件，用于分析训练各阶段的时间。
+
+### Analyser
+
+#### Analyser模块介绍
+
+分析器的作用是对解析阶段生成的中间结果，进行筛选、排序、查询、分页等相关操作。
+
+#### Analyser模块设计
+
+该模块负责解析Parser生成的中间文件，为上层数据分析提供通用接口，将分析后的数据返回给上层展示给用户，由于各种中间文件有一定的共同点，可以抽象出公共内容，所以Analyser类设计如下图所示：
+
+
+
+图5：Analyser类图
+
+如上图所示，针对期望查询的不同内容，实现多个Analyser，每个Analyser可以定义筛选、排序、分页条件。每个Analyser知道自己需要哪些中间文件来进行数据的合并、筛选、排序。Analyser与Parser是通过Parser生成的中间文件关联起来的，本身不存在函数调用的情况，这样对两个模块进行了解耦。
+
+针对算子信息的Analyser，目前存在两种：
+
+- 针对算子类型平均信息的筛选。
+- 针对每个算子详细平均信息的筛选，分别在两个Analyser中实现（AicoreTypeAnalyser、AicoreDetailAnalyser）。
+
+为了隐藏Analyser内部实现，方便调用，使用简单工厂模式，通过AnalyserFactory获取指定的Analyser。
+
+### Proposer
+
+#### Proposer模块介绍
+
+Proposer是Profiler性能优化建议模块，Proposer调用Analyser模块获取性能数据，通过调优规则对性能数据进行分析，输出调优建议由UI、API接口展示给用户。
+
+#### Proposer模块设计
+
+模块划分如下所示：
+
+
+
+图6：Proposer模块图
+
+模块设计如上图所示：
+
+- Proposer提供接口用于API、RESTful调用以获取优化建议。
+- Proposer调用Analyser接口，获取性能数据并根据优化规则，获得优化建议。
+- Proposer调用Analyser工厂获得Analyser对象。
+
+调用Analyser对象的query接口获取信息，包括：按时间排序TOP N的AICore、AICoreType、AICpu算子信息、traning trace各阶段的时间信息。
+
+模块类设计如下所示：
+
+
+
+图7：Proposer类图
+
+如上模块类图所示：
+
+- 各类型Proposer继承抽象类Proposer并实现analyze方法；
+- API、CLI通过调用工厂ProposerFactory获取Proposer，并调用Proposer.analyze函数获取各类型的Proposer分析的优化建议。
diff --git a/docs/note/source_zh_cn/design/overall.rst b/docs/note/source_zh_cn/design/overall.rst
new file mode 100644
index 0000000000000000000000000000000000000000..41fc8d134005a2a30ef0019440d0738a53654ad1
--- /dev/null
+++ b/docs/note/source_zh_cn/design/overall.rst
@@ -0,0 +1,9 @@
+总体设计
+========
+
+.. toctree::
+ :maxdepth: 1
+
+ technical_white_paper
+ mindspore/architecture
+ mindspore/architecture_lite
diff --git a/docs/source_zh_cn/technical_white_paper.md b/docs/note/source_zh_cn/design/technical_white_paper.md
similarity index 92%
rename from docs/source_zh_cn/technical_white_paper.md
rename to docs/note/source_zh_cn/design/technical_white_paper.md
index 29f1d3e4e211f3e8b7e02424fea1ef7b87165577..61304b9e57ce9c36cce1fe1914912bb3d8fcdfdb 100644
--- a/docs/source_zh_cn/technical_white_paper.md
+++ b/docs/note/source_zh_cn/design/technical_white_paper.md
@@ -10,14 +10,16 @@
-
+
## 引言
+
深度学习研究和应用在近几十年得到了爆炸式的发展，掀起了人工智能的第三次浪潮，并且在图像识别、语音识别与合成、无人驾驶、机器视觉等方面取得了巨大的成功。这也对算法的应用以及依赖的框架有了更高级的要求。深度学习框架的不断发展使得在大型数据集上训练神经网络模型时，可以方便地使用大量的计算资源。
深度学习是使用多层结构从原始数据中自动学习并提取高层次特征的一类机器学习算法。通常，从原始数据中提取高层次、抽象的特征是非常困难的。目前有两种主流的深度学习框架：一种是在执行之前构造一个静态图，定义所有操作和网络结构，典型代表是TensorFlow，这种方法以牺牲易用性为代价，来提高训练期间的性能；另一种是立即执行的动态图计算，典型代表是PyTorch。通过比较可以发现，动态图更灵活、更易调试，但会牺牲性能。因此，现有深度学习框架难以同时满足易开发、高效执行的要求。
## 简介
+
MindSpore作为新一代深度学习框架，是源于全产业的最佳实践，最佳匹配昇腾处理器算力，支持终端、边缘、云全场景灵活部署，开创全新的AI编程范式，降低AI开发门槛。MindSpore是一种全新的深度学习计算框架，旨在实现易开发、高效执行、全场景覆盖三大目标。为了实现易开发的目标，MindSpore采用基于源码转换（Source Code Transformation，SCT）的自动微分（Automatic Differentiation，AD）机制，该机制可以用控制流表示复杂的组合。函数被转换成函数中间表达（Intermediate Representation，IR），中间表达构造出一个能够在不同设备上解析和执行的计算图。在执行前，计算图上应用了多种软硬件协同优化技术，以提升端、边、云等不同场景下的性能和效率。MindSpore支持动态图，更易于检查运行模式。由于采用了基于源码转换的自动微分机制，所以动态图和静态图之间的模式切换非常简单。为了在大型数据集上有效训练大模型，通过高级手动配置策略，MindSpore可以支持数据并行、模型并行和混合并行训练，具有很强的灵活性。此外，MindSpore还有“自动并行”能力，它通过在庞大的策略空间中进行高效搜索来找到一种快速的并行策略。MindSpore框架的具体优势，请查看详细介绍。
-[查看技术白皮书](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/white_paper/MindSpore_white_paper.pdf)
\ No newline at end of file
+[查看技术白皮书](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/white_paper/MindSpore_white_paper.pdf)
diff --git a/docs/source_zh_cn/glossary.md b/docs/note/source_zh_cn/glossary.md
similarity index 85%
rename from docs/source_zh_cn/glossary.md
rename to docs/note/source_zh_cn/glossary.md
index 647c9076f97496a863d4f9ba88e06df4f2beb908..6905f4fb455077b71868927cb2238f350d9467e2 100644
--- a/docs/source_zh_cn/glossary.md
+++ b/docs/note/source_zh_cn/glossary.md
@@ -2,9 +2,9 @@
`Linux` `Windows` `Ascend` `GPU` `CPU` `全流程` `初级` `中级` `高级`
-
+
-| 术语/缩略语 | 说明 |
+| 术语/缩略语 | 说明 |
| ----- | ----- |
| ACL | Ascend Computer Language，提供Device管理、Context管理、Stream管理、内存管理、模型加载与执行、算子加载与执行、媒体数据处理等C++ API库，供用户开发深度神经网络应用。|
| Ascend | 华为昇腾系列芯片的系列名称。 |
@@ -32,9 +32,10 @@
| LSTM | Long short-term memory，长短期记忆，对应的网络是一种时间循环神经网络，适合于处理和预测时间序列中间隔和延迟非常长的重要事件。 |
| Manifest | 一种数据格式文件，华为ModelArts采用了该格式，详细说明请参见
+
本文将简述用户在使用MindSpore遇到问题时，如何使用官方提供的问题求助路径解决问题。MindSpore问题求助整体流程如图中所示，从用户使用MindSpore发现问题开始，直至选择到合适的问题解决方法。下面我们基于问题求助流程图对各种求助方法做解释说明。
@@ -10,25 +10,23 @@
- 网站搜索
- - 进入[官网搜索](https://www.mindspore.cn/search)。
- - 遇到问题时，首先推荐使用网站搜索方法，该方法操作简单、高效。
- - 在搜索框输入问题的关键词，点击搜索，可匹配出与关键词相关的内容。
- - 参考搜索结果，解决当前遇到的问题。
-
+ - 进入[官网搜索](https://www.mindspore.cn/search)。
+ - 遇到问题时，首先推荐使用网站搜索方法，该方法操作简单、高效。
+ - 在搜索框输入问题的关键词，点击搜索，可匹配出与关键词相关的内容。
+ - 参考搜索结果，解决当前遇到的问题。
- 用户群咨询
- - QQ用户群号：871543426。
- - 如果网站搜索方法不能解决当前问题，可通过QQ用户群咨询，建议想要简单咨询的用户选取此方法。
- - 加群后可以与其他用户讨论交流，还有技术专家在群中提供帮助解答。
- - 通过专家的解答或和其他用户的交流来解决当前遇到的问题。
-
+ - QQ用户群号：871543426。
+ - 如果网站搜索方法不能解决当前问题，可通过QQ用户群咨询，建议想要简单咨询的用户选取此方法。
+ - 加群后可以与其他用户讨论交流，还有技术专家在群中提供帮助解答。
+ - 通过专家的解答或和其他用户的交流来解决当前遇到的问题。
- 论坛求助
- - 如果用户想要详细的解决方法，可通过[MindSpore论坛](https://bbs.huaweicloud.com/forum/forum-1076-1.html)中发布问题求助帖获取解答。
- - 为提高问题解决速度与质量，发帖前请参考[发帖建议](https://bbs.huaweicloud.com/forum/thread-69695-1-1.html)，按照建议格式发帖。
- - 帖子发出后会有论坛版主负责将问题收录，并联系技术专家进行解答，问题将在三个工作日内解决。
- - 参考技术专家的解决方案，解决当前遇到的问题。
-
- 如果在专家测试后确定是MindSpore功能有待完善，推荐用户在[MindSpore仓](https://gitee.com/mindspore)中创建ISSUE，所提问题会在后续的版本中得到修复完善。
\ No newline at end of file
+ - 如果用户想要详细的解决方法，可通过[MindSpore论坛](https://bbs.huaweicloud.com/forum/forum-1076-1.html)中发布问题求助帖获取解答。
+ - 为提高问题解决速度与质量，发帖前请参考[发帖建议](https://bbs.huaweicloud.com/forum/thread-69695-1-1.html)，按照建议格式发帖。
+ - 帖子发出后会有论坛版主负责将问题收录，并联系技术专家进行解答，问题将在三个工作日内解决。
+ - 参考技术专家的解决方案，解决当前遇到的问题。
+
+ 如果在专家测试后确定是MindSpore功能有待完善，推荐用户在[MindSpore仓](https://gitee.com/mindspore)中创建ISSUE，所提问题会在后续的版本中得到修复完善。
diff --git a/docs/note/source_zh_cn/image_classification_lite.md b/docs/note/source_zh_cn/image_classification_lite.md
new file mode 100644
index 0000000000000000000000000000000000000000..259ae64511f797d8db12dc63245551ff5191f119
--- /dev/null
+++ b/docs/note/source_zh_cn/image_classification_lite.md
@@ -0,0 +1,32 @@
+# 图像分类模型支持（Lite）
+
+
+
+## 图像分类介绍
+
+图像分类模型可以预测图片中出现哪些物体，识别出图片中出现物体列表及其概率。 比如下图经过模型推理的分类结果为下表：
+
+
+
+| 类别 | 概率 |
+| ---------- | ------ |
+| plant | 0.9359 |
+| flower | 0.8641 |
+| tree | 0.8584 |
+| houseplant | 0.7867 |
+
+使用MindSpore Lite实现图像分类的[示例代码](https://gitee.com/mindspore/mindspore/tree/r1.0/model_zoo/official/lite/image_classification)。
+
+## 图像分类模型列表
+
+下表是使用MindSpore Lite推理的部分图像分类模型的数据。
+
+> 下表的性能是在mate30手机上测试的。
+
+| 模型名称 | 大小(Mb) | Top1 | Top5 | F1 | CPU 4线程时延(ms) |
+|-----------------------| :----------: | :----------: | :----------: | :----------: | :-----------: |
+| [MobileNetV2](https://download.mindspore.cn/model_zoo/official/lite/mobilenetv2_openimage_lite/mobilenetv2.ms) | 11.5 | - | - | 65.5% | 14.595 |
+| [Inceptionv3](https://download.mindspore.cn/model_zoo/official/lite/inceptionv3_lite/inceptionv3.ms) | 90.9 | 78.62% | 94.08% | - | 92.086 |
+| [Shufflenetv2](https://download.mindspore.cn/model_zoo/official/lite/shufflenetv2_lite/shufflenetv2.ms) | 8.8 | 67.74% | 87.62% | - | 8.303 |
+| [GoogleNet](https://download.mindspore.cn/model_zoo/official/lite/googlenet_lite/googlenet.ms) | 25.3 | 72.2% | 90.06% | - | 23.257 |
+| [ResNext50](https://download.mindspore.cn/model_zoo/official/lite/resnext50_lite/resnext50.ms) | 95.8 | 73.1% | 91.21% | - | 138.164 |
diff --git a/docs/source_zh_cn/images/help_seeking_path.png b/docs/note/source_zh_cn/images/help_seeking_path.png
similarity index 100%
rename from docs/source_zh_cn/images/help_seeking_path.png
rename to docs/note/source_zh_cn/images/help_seeking_path.png
diff --git a/lite/tutorials/source_zh_cn/images/lite_quick_start_app_result.png b/docs/note/source_zh_cn/images/image_classification_result.png
similarity index 100%
rename from lite/tutorials/source_zh_cn/images/lite_quick_start_app_result.png
rename to docs/note/source_zh_cn/images/image_classification_result.png
diff --git a/docs/note/source_zh_cn/images/object_detection.png b/docs/note/source_zh_cn/images/object_detection.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad5425c86393a9367701166796df42c9e4702988
Binary files /dev/null and b/docs/note/source_zh_cn/images/object_detection.png differ
diff --git a/docs/source_zh_cn/index.rst b/docs/note/source_zh_cn/index.rst
similarity index 55%
rename from docs/source_zh_cn/index.rst
rename to docs/note/source_zh_cn/index.rst
index 91ddd47bd41b271296d377dcb5044aa6af87df45..63f66e09d53b76faaa6a0abbf0b939c10f41a3ba 100644
--- a/docs/source_zh_cn/index.rst
+++ b/docs/note/source_zh_cn/index.rst
@@ -3,20 +3,38 @@
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
-MindSpore文档
-=================
+MindSpore说明
+==============
.. toctree::
:glob:
:maxdepth: 1
+ :caption: 设计说明
+
+ design/overall
+ design/mindspore
+ design/mindinsight
+ design/mindarmour
+
+.. toctree::
+ :glob:
+ :maxdepth: 1
+ :caption: 规格说明
- design
- roadmap
benchmark
network_list
operator_list
constraints_on_network_construction
+ image_classification_lite
+ object_detection_lite
+
+.. toctree::
+ :glob:
+ :maxdepth: 1
+ :caption: 其他说明
+
glossary
- FAQ
+ roadmap
help_seeking_path
community
+
\ No newline at end of file
diff --git a/tutorials/source_zh_cn/advanced_use/auto_data_acceleration.rst b/docs/note/source_zh_cn/network_list.rst
similarity index 30%
rename from tutorials/source_zh_cn/advanced_use/auto_data_acceleration.rst
rename to docs/note/source_zh_cn/network_list.rst
index 003693d04b59d55bc6673bd1fe49c7550a296bac..e70ac86c49ea5a6903bff4ca49a9667b48b43500 100644
--- a/tutorials/source_zh_cn/advanced_use/auto_data_acceleration.rst
+++ b/docs/note/source_zh_cn/network_list.rst
@@ -1,8 +1,7 @@
-自动数据加速
-========
+网络支持
+===========
.. toctree::
:maxdepth: 1
- data_processing_acceleration
- cache
+ network_list_ms
\ No newline at end of file
diff --git a/docs/note/source_zh_cn/network_list_ms.md b/docs/note/source_zh_cn/network_list_ms.md
new file mode 100644
index 0000000000000000000000000000000000000000..8f51b2a13ebc9c5de7664a0dad0a3831048f7f99
--- /dev/null
+++ b/docs/note/source_zh_cn/network_list_ms.md
@@ -0,0 +1,49 @@
+# MindSpore网络支持
+
+`Linux` `Ascend` `GPU` `CPU` `模型开发` `中级` `高级`
+
+
+
+- [MindSpore网络支持](#mindspore网络支持)
+ - [Model Zoo](#model-zoo)
+
+
+
+
+
+## Model Zoo
+
+| 领域 | 子领域 | 网络 | Ascend(Graph) | Ascend(PyNative) | GPU(Graph) | GPU(PyNaitve) | CPU(Graph)
+|:---- |:------- |:---- |:---- |:---- |:---- |:---- |:----
+|计算机视觉（CV） | 图像分类（Image Classification） | [AlexNet](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/alexnet/src/alexnet.py) | Supported | Supported | Supported | Supported | Doing
+| 计算机视觉（CV） | 图像分类（Image Classification） | [GoogleNet](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/googlenet/src/googlenet.py) | Supported | Supported | Supported | Supported | Doing
+| 计算机视觉（CV） | 图像分类（Image Classification） | [LeNet](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/lenet/src/lenet.py) | Supported | Supported | Supported | Supported | Supported
+| 计算机视觉（CV） | 图像分类（Image Classification） | [ResNet-50](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Supported | Supported | Supported | Doing
+|计算机视觉（CV） | 图像分类（Image Classification） | [ResNet-101](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Supported | Supported | Supported | Doing
+|计算机视觉（CV） | 图像分类（Image Classification） | [SE-ResNet50](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Doing | Doing | Doing | Doing
+|计算机视觉（CV） | 图像分类（Image Classification） | [ResNext50](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/resnext50/src/image_classification.py) | Supported | Supported | Supported | Supported | Doing
+| 计算机视觉（CV） | 图像分类（Image Classification） | [VGG16](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/vgg16/src/vgg.py) | Supported | Supported | Supported | Supported | Doing
+| 计算机视觉（CV） | 图像分类（Image Classification） | [InceptionV3](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/inceptionv3/src/inception_v3.py) | Supported | Supported | Doing | Doing | Doing
+| 计算机视觉（CV） | 图像分类（Image Classification） | [DenseNet121](https://gitee.com/mindspore/mindspore/blob/r1.0/model_zoo/official/cv/densenet121/src/network/densenet.py) | Supported | Doing | Doing | Doing | Doing
+| 计算机视觉（CV） | 移动端图像分类（Mobile Image Classification）
+
+## 目标检测介绍
+
+目标检测可以识别出图片中的对象和该对象在图片中的位置。 如：对下图使用目标检测模型的输出如下表所示，使用矩形框识别图中目标对象的位置并且标注出目标对象类别的概率，其中坐标中的4个数字分别为Xmin，Ymin,，Xmax,，Ymax；概率表示反应被检测物理的可信程度。
+
+
+
+| 类别 | 概率 | 坐标 |
+| ----- | ---- | ---------------- |
+| mouse | 0.78 | [10, 25, 35, 43] |
+
+使用MindSpore Lite实现目标检测的[示例代码](https://gitee.com/mindspore/mindspore/tree/r1.0/model_zoo/official/lite/object_detection)。
+
+## 目标检测模型列表
+
+下表是使用MindSpore Lite推理的部分目标检测模型的数据。
+
+> 下表的性能是在mate30手机上测试的。
+
+| 模型名称 | 大小 | mAP(IoU=0.50:0.95) | CPU 4线程时延(ms) |
+|-----------------------| :----------: | :----------: | :-----------: |
+| [MobileNetv2-SSD](https://download.mindspore.cn/model_zoo/official/lite/ssd_mobilenetv2_lite/ssd.ms) | 16.7 | 0.22 | 25.4 |
diff --git a/docs/note/source_zh_cn/operator_list.rst b/docs/note/source_zh_cn/operator_list.rst
new file mode 100644
index 0000000000000000000000000000000000000000..4a5895cf24b6a9bb5a9505707a00e9097fcc175f
--- /dev/null
+++ b/docs/note/source_zh_cn/operator_list.rst
@@ -0,0 +1,10 @@
+算子支持
+===========
+
+.. toctree::
+ :maxdepth: 1
+
+ operator_list_ms
+ operator_list_implicit
+ operator_list_parallel
+ operator_list_lite
\ No newline at end of file
diff --git a/docs/note/source_zh_cn/operator_list_implicit.md b/docs/note/source_zh_cn/operator_list_implicit.md
new file mode 100644
index 0000000000000000000000000000000000000000..98a4e5621e4bc9c72619d343c1b27f612cc9c7a3
--- /dev/null
+++ b/docs/note/source_zh_cn/operator_list_implicit.md
@@ -0,0 +1,104 @@
+# MindSpore隐式类型转换的算子支持
+
+`Linux` `Ascend` `GPU` `CPU` `模型开发` `初级` `中级` `高级`
+
+
+
+- [MindSpore隐式类型转换的算子支持](#mindspore隐式类型转换的算子支持)
+ - [隐式类型转换](#隐式类型转换)
+ - [转换规则](#转换规则)
+ - [参与转换的数据类型](#参与转换的数据类型)
+ - [支持算子](#支持算子)
+
+
+
+
+
+## 隐式类型转换
+
+### 转换规则
+
+- 标量与Tensor运算：运算时，将标量自动转为Tensor，数据类型和参与运算的Tensor数据类型保持一致；而当Tensor是bool数据类型，标量是int或float时，将标量和Tensor都转为数据类型为int32或float32的Tensor。
+- 不同数据类型Tensor运算：数据类型优先级排序为bool < uint8 < int8 < int16 < int32 < int64 < float16 < float32 < float64，运算时，先确定参与运算的Tensor中优先级相对最高的数据类型，然后将低优先级数据类型Tensor转换为相对最高优先级数据类型；而当int8和uint8数据类型的Tensor进行运算时，将其都转为int16的Tensor。
+- 不支持对Parameter进行数据类型转换：如果按照转换规则推导，需要对网络中定义的Parameter进行数据类型转换时，会抛出RuntimeError异常。
+
+### 参与转换的数据类型
+
+- bool
+- int8
+- uint8
+- int16
+- int32
+- int64
+- float16
+- float32
+- float64
+
+### 支持算子
+
+| 算子名
+| :-----------
+| [mindspore.ops.Assign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Assign)
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub)
+| [mindspore.ops.ApplyMomentum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyMomentum)
+| [mindspore.ops.FusedSparseAdam](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseAdam)
+| [mindspore.ops.FusedSparseLazyAdam](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseLazyAdam)
+| [mindspore.ops.FusedSparseFtrl](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseFtrl)
+| [mindspore.ops.FusedSparseProximalAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseProximalAdagrad)
+| [mindspore.ops.ApplyAdaMax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdaMax)
+| [mindspore.ops.ApplyAdadelta](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdadelta)
+| [mindspore.ops.ApplyAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdagrad)
+| [mindspore.ops.ApplyAdagradV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAdagradV2)
+| [mindspore.ops.SparseApplyAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagrad)
+| [mindspore.ops.SparseApplyAdagradV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagradV2)
+| [mindspore.ops.ApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalAdagrad)
+| [mindspore.ops.SparseApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyProximalAdagrad)
+| [mindspore.ops.ApplyAddSign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAddSign)
+| [mindspore.ops.ApplyPowerSign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyPowerSign)
+| [mindspore.ops.ApplyGradientDescent](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyGradientDescent)
+| [mindspore.ops.ApplyProximalGradientDescent](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalGradientDescent)
+| [mindspore.ops.SparseApplyFtrl](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrl)
+| [mindspore.ops.SparseApplyFtrlV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrlV2)
+| [mindspore.ops.BitwiseAnd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseAnd)
+| [mindspore.ops.BitwiseOr](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseOr)
+| [mindspore.ops.BitwiseXor](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseXor)
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd)
+| [mindspore.ops.Sub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sub)
+| [mindspore.ops.Mul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mul)
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow)
+| [mindspore.ops.Minimum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Minimum)
+| [mindspore.ops.Maximum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Maximum)
+| [mindspore.ops.RealDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RealDiv)
+| [mindspore.ops.Div](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Div)
+| [mindspore.ops.DivNoNan](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DivNoNan)
+| [mindspore.ops.FloorDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorDiv)
+| [mindspore.ops.TruncateDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateDiv)
+| [mindspore.ops.TruncateMod](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateMod)
+| [mindspore.ops.Mod](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mod)
+| [mindspore.ops.FloorMod](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorMod)
+| [mindspore.ops.Atan2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Atan2)
+| [mindspore.ops.SquaredDifference](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SquaredDifference)
+| [mindspore.ops.Xdivy](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xdivy)
+| [mindspore.ops.Xlogy](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xlogy)
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal)
+| [mindspore.ops.ApproximateEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApproximateEqual)
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual)
+| [mindspore.ops.Greater](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Greater)
+| [mindspore.ops.GreaterEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GreaterEqual)
+| [mindspore.ops.Less](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Less)
+| [mindspore.ops.LessEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LessEqual)
+| [mindspore.ops.LogicalAnd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalAnd)
+| [mindspore.ops.LogicalOr](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalOr)
+| [mindspore.ops.ScatterNdUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdUpdate)
+| [mindspore.ops.ScatterNdAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdAdd)
+| [mindspore.ops.ScatterNdSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdSub)
+| [mindspore.ops.ScatterNonAliasingAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNonAliasingAdd)
+| [mindspore.ops.ScatterUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterUpdate)
+| [mindspore.ops.ScatterMax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMax)
+| [mindspore.ops.ScatterMin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMin)
+| [mindspore.ops.ScatterAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterAdd)
+| [mindspore.ops.ScatterSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterSub)
+| [mindspore.ops.ScatterMul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMul)
+| [mindspore.ops.ScatterDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterDiv)
+
+>
\ No newline at end of file
diff --git a/docs/note/source_zh_cn/operator_list_lite.md b/docs/note/source_zh_cn/operator_list_lite.md
new file mode 100644
index 0000000000000000000000000000000000000000..0090a07552d658290f9edcf10c497be765c9bc48
--- /dev/null
+++ b/docs/note/source_zh_cn/operator_list_lite.md
@@ -0,0 +1,114 @@
+# MindSpore Lite算子支持
+
+`Linux` `Ascend` `端侧` `推理应用` `初级` `中级` `高级`
+
+
+
+| 操作名 | CPU
+
+## mindspore.nn
+
+| 操作名 | Ascend | GPU | CPU |算子类别
+| :----------- |:------ |:------ |:-----|:---
+| [mindspore.nn.Softmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Softmax) | Supported | Supported | Supported |layer/activation
+| [mindspore.nn.LogSoftmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LogSoftmax) | Supported | Supported | Doing |layer/activation
+| [mindspore.nn.ReLU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ReLU) | Supported | Supported | Supported |layer/activation
+| [mindspore.nn.ReLU6](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ReLU6) |Supported | Supported | Supported |layer/activation
+| [mindspore.nn.HSwish](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSwish) | Doing | Supported | Doing |layer/activation
+| [mindspore.nn.HSigmoid](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSigmoid) | Doing | Supported | Doing |layer/activation
+| [mindspore.nn.LeakyReLU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LeakyReLU) | Supported |Supported | Doing |layer/activation
+| [mindspore.nn.Tanh](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Tanh) | Supported | Supported | Doing |layer/activation
+| [mindspore.nn.GELU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GELU) | Supported | Supported | Doing |layer/activation
+| [mindspore.nn.Sigmoid](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Sigmoid) | Supported |Supported | Doing |layer/activation
+| [mindspore.nn.PReLU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.PReLU) | Supported |Doing | Doing |layer/activation
+| [mindspore.nn.Dropout](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Dropout) |Supported | Supported | Supported |layer/basic
+| [mindspore.nn.Flatten](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Flatten) |Supported | Supported | Supported |layer/basic
+| [mindspore.nn.Dense](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Dense) |Supported | Supported | Supported |layer/basic
+| [mindspore.nn.ClipByNorm](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ClipByNorm) |Supported | Supported | Doing |layer/basic
+| [mindspore.nn.Norm](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Norm) |Supported | Supported | Doing |layer/basic
+| [mindspore.nn.OneHot](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.OneHot) | Supported | Supported | Supported |layer/basic
+| [mindspore.nn.Range](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Range) | Supported | Doing | Doing |layer/basic
+| [mindspore.nn.SequentialCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SequentialCell) |Supported | Supported | Doing |layer/container
+| [mindspore.nn.CellList](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.CellList) | Supported | Supported | Doing |layer/container
+| [mindspore.nn.Conv2d](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2d) | Supported | Supported | Supported |layer/conv
+| [mindspore.nn.Conv2dTranspose](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dTranspose) | Supported | Supported | Doing |layer/conv
+| [mindspore.nn.Conv1d](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv1d) | Supported | Supported | Doing |layer/conv
+| [mindspore.nn.Conv1dTranspose](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv1dTranspose) | Supported | Supported | Doing |layer/conv
+| [mindspore.nn.Embedding](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Embedding) |Supported | Supported | Doing |layer/embedding
+| [mindspore.nn.ImageGradients](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ImageGradients) | Supported |Supported | Doing |layer/image
+| [mindspore.nn.SSIM](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SSIM) | Supported | Supported | Doing |layer/image
+| [mindspore.nn.PSNR](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.PSNR) | Supported |Supported | Doing |layer/image
+| [mindspore.nn.CentralCrop](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.CentralCrop) | Supported |Supported | Doing |layer/image
+| [mindspore.nn.LSTM](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LSTM) | Doing | Supported | Doing |layer/lstm
+| [mindspore.nn.LSTMCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LSTMCell) | Doing | Supported | Supported |layer/lstm
+| [mindspore.nn.GlobalBatchNorm](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GlobalBatchNorm) | Supported |Doing | Doing |layer/normalization
+| [mindspore.nn.BatchNorm1d](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm1d) | Supported |Doing | Doing |layer/normalization
+| [mindspore.nn.BatchNorm2d](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm2d) | Supported | Supported | Doing |layer/normalization
+| [mindspore.nn.GroupNorm](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GroupNorm) | Supported | Doing | Doing |layer/normalization
+| [mindspore.nn.LayerNorm](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LayerNorm) | Supported | Supported | Doing |layer/normalization
+| [mindspore.nn.MatrixDiag](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiag) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.MatrixDiagPart](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiagPart) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.MatrixSetDiag](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatrixSetDiag) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.LinSpace](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LinSpace) | Supported | Doing | Doing | layer/normalization
+| [mindspore.nn.MaxPool2d](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MaxPool2d) | Supported | Supported | Supported |layer/pooling
+| [mindspore.nn.AvgPool2d](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.AvgPool2d) | Supported | Supported | Doing |layer/pooling
+| [mindspore.nn.DenseBnAct](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DenseBnAct) |Supported | Supported | Supported |layer/quant
+| [mindspore.nn.Conv2dBnAct](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnAct) | Supported | Supported | Supported |layer/quant
+| [mindspore.nn.FakeQuantWithMinMax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.FakeQuantWithMinMax) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.Conv2dBnFoldQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnFoldQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.Conv2dBnWithoutFoldQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnWithoutFoldQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.Conv2dQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Conv2dQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.DenseQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DenseQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.ActQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ActQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.LeakyReLUQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LeakyReLUQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.HSwishQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSwishQuant) | Doing | Supported | Doing |layer/quant
+| [mindspore.nn.HSigmoidQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.HSigmoidQuant) | Doing | Supported | Doing |layer/quant
+| [mindspore.nn.TensorAddQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.TensorAddQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.MulQuant](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MulQuant) | Supported | Supported | Doing |layer/quant
+| [mindspore.nn.L1Loss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.L1Loss) |Supported |Supported | Doing |loss/loss
+| [mindspore.nn.MSELoss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MSELoss) | Supported |Supported | Doing |loss/loss
+| [mindspore.nn.SmoothL1Loss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SmoothL1Loss) | Supported |Doing | Doing |loss/loss
+| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits) | Supported | Supported | Supported |loss/loss
+| [mindspore.nn.CosineEmbeddingLoss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.CosineEmbeddingLoss) |Supported |Supported | Doing |loss/loss
+| [mindspore.nn.ProximalAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ProximalAdagrad) | Supported |Doing | Doing |optim/ProximalAdagrad
+| [mindspore.nn.LazyAdam](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LazyAdam) | Supported |Doing | Doing |optim/lazyadam
+| [mindspore.nn.Adam](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Adam) | Supported |Doing | Doing |optim/adam
+| [mindspore.nn.AdamWeightDecay](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.AdamWeightDecay) | Supported | Supported | Doing |optim/adam
+| [mindspore.nn.Lamb](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Lamb) | Supported | Supported | Doing |optim/lamb
+| [mindspore.nn.LARS](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LARS) |Supported |Doing | Doing |optim/lars
+| [mindspore.nn.Momentum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Momentum) | Supported | Supported | Supported |optim/momentum
+| [mindspore.nn.Optimizer](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Optimizer) | Supported | Supported | Doing |optim/optimizer
+| [mindspore.nn.RMSProp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.RMSProp) | Supported | Supported | Doing |optim/optimizer
+| [mindspore.nn.SGD](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.SGD) |Supported |Supported | Doing |optim/sgd
+| [mindspore.nn.WithLossCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.WithLossCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.WithGradCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.WithGradCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.TrainOneStepCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.GetNextSingleOp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.GetNextSingleOp) |Doing | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.WithEvalCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.WithEvalCell) | Supported | Supported | Doing |wrap/cell_wrapper
+| [mindspore.nn.ParameterUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ParameterUpdate) | Supported |Doing | Doing |wrap/cell_wrapper
+| [mindspore.nn.DistributedGradReducer](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DistributedGradReducer) | Supported |Doing | Doing |wrap/grad_reducer
+| [mindspore.nn.DynamicLossScaleUpdateCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.DynamicLossScaleUpdateCell) | Supported |Supported | Doing |wrap/loss_scale
+| [mindspore.nn.FixedLossScaleUpdateCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.FixedLossScaleUpdateCell) | Supported |Supported | Doing |wrap/loss_scale
+| [mindspore.nn.TrainOneStepWithLossScaleCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepWithLossScaleCell) | Supported |Supported | Doing |wrap/loss_scale
+| [mindspore.nn.Cell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Cell) | Supported | Supported | Supported |cell
+| [mindspore.nn.EmbeddingLookup](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.EmbeddingLookup) |Supported | Supported | Supported |layer/embedding
+| [mindspore.nn.Pad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Pad) |Supported | Supported | Doing |layer/basic
+| [mindspore.nn.MatMul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MatMul) |Supported | Doing | Doing |layer/math
+| [mindspore.nn.LGamma](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.LGamma) |Supported | Doing | Doing |layer/math
+| [mindspore.nn.ReduceLogSumExp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.ReduceLogSumExp) |Supported | Supported | Doing |layer/math
+| [mindspore.nn.MSSSIM](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.MSSSIM) | Supported |Doing | Doing |layer/image
+
+## mindspore.ops.operations
+
+| 操作名 | Ascend | GPU | CPU |算子类别
+| :----------- |:------ |:------ |:-----|:---
+| [mindspore.ops.Flatten](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Flatten) | Supported | Supported |Supported | nn_ops
+| [mindspore.ops.Softmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softmax) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.Acosh](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Acosh) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.FloorMod](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorMod) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.Elu](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Elu) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.MirrorPad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MirrorPad) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.Unpack](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Unpack) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.Pack](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pack) | Supported| Doing | Doing | nn_ops
+| [mindspore.ops.L2Loss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.L2Loss) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.CTCLoss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CTCLoss) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.RNNTLoss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RNNTLoss) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.LogSoftmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogSoftmax) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.Softplus](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softplus) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.ReLU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLU) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.ReLU6](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLU6) | Supported | Supported |Supported | nn_ops
+| [mindspore.ops.HSwish](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HSwish) | Doing | Supported |Doing | nn_ops
+| [mindspore.ops.HSigmoid](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HSigmoid) | Doing | Supported |Doing | nn_ops
+| [mindspore.ops.Sigmoid](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sigmoid) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.Tanh](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tanh) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.BatchNorm](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchNorm) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.LRN](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LRN) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.Conv2D](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Conv2D) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.DepthwiseConv2dNative](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthwiseConv2dNative) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.DepthwiseConv2dNativeBackpropInput](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthwiseConv2dNativeBackpropInput) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.DepthwiseConv2dNativeiBackpropFilter](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthwiseConv2dNativeBackpropFilter) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.MaxPoolWithArgmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MaxPoolWithArgmax) | Supported | Doing |Doing | nn_ops
+| [mindspore.ops.MaxPool](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MaxPool) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.AvgPool](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AvgPool) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.Conv2DBackpropInput](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Conv2DBackpropInput) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.BiasAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BiasAdd) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.TopK](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TopK) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SoftmaxCrossEntropyWithLogits) | Supported | Supported |Doing | nn_ops
+| [mindspore.ops.SparseSoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseSoftmaxCrossEntropyWithLogits) | Doing | Supported | Supported | nn_ops
+| [mindspore.ops.ApplyMomentum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyMomentum) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.ApplyAddSign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyAddSign) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyPowerSign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyPowerSign) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyGradientDescent](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyGradientDescent) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyProximalGradientDescent](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalGradientDescent) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ApplyRMSProp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyRMSProp) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.ApplyCenteredRMSProp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyCenteredRMSProp) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.SparseApplyAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagrad) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.SparseApplyAdagradV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyAdagradV2) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.SparseApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.FusedSparseProximalAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseProximalAdagrad) | Doing | Doing | Supported | nn_ops
+| [mindspore.ops.ApplyProximalAdagrad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.FusedSparseLazyAdam](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseLazyAdam) | Doing | Doing | Supported | nn_ops
+| [mindspore.ops.FusedSparseAdam](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseAdam) | Doing | Doing | Supported | nn_ops
+| [mindspore.ops.SmoothL1Loss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SmoothL1Loss) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.SGD](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SGD) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.LayerNorm](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LayerNorm) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.L2Normalize](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.L2Normalize) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.DropoutGenMask](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutGenMask) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.DropoutDoMask](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutDoMask) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.ResizeBilinear](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ResizeBilinear) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.OneHot](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OneHot) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.Gelu](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Gelu) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.GetNext](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GetNext) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.PReLU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.PReLU) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.LSTM](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LSTM) | Doing | Supported | Supported | nn_ops
+| [mindspore.ops.BasicLSTMCell](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BasicLSTMCell) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SigmoidCrossEntropyWithLogits) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.Pad](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pad) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.ROIAlign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ROIAlign) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.Adam](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Adam) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.BinaryCrossEntropy](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BinaryCrossEntropy) | Supported | Supported | Doing | nn_ops
+| [mindspore.ops.KLDivLoss](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.KLDivLoss) | Doing | Supported | Doing | nn_ops
+| [mindspore.ops.LARSUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LARSUpdate) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.Softsign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softsign) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.AssignAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignAdd) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ReduceMean](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMean) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.ReduceSum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceSum) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.ReduceAll](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceAll) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ReduceMax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMax) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.ReduceMin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMin) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.ReduceProd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceProd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.CumProd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CumProd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.MatMul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MatMul) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.BatchMatMul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchMatMul) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.CumSum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CumSum) | Supported | Supported| Doing | math_ops
+| [mindspore.ops.AddN](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AddN) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.Neg](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Neg) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sub) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.Mul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mul) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.Square](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Square) | Supported | Supported | Supported | math_ops
+| [mindspore.ops.SquareSumAll](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SquareSumAll) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Rsqrt](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rsqrt) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sqrt](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sqrt) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Reciprocal](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reciprocal) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Exp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Exp) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Log](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Log) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Log1p](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Log1p) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Minimum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Minimum) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Maximum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Maximum) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.RealDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RealDiv) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Div](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Div) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.DivNoNan](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DivNoNan) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.FloorDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorDiv) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Floor](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Floor) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.EqualCount](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.EqualCount) | Doing | Supported | Supported | math_ops
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Greater](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Greater) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.GreaterEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GreaterEqual) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Less](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Less) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Atan2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Atan2) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.LessEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LessEqual) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.LogicalNot](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalNot) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.LogicalAnd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalAnd) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.LogicalOr](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalOr) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.BitwiseAnd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseAnd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BitwiseOr](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseOr) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BitwiseXor](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BitwiseXor) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Ceil](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Ceil) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Inv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Inv) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Invert](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Invert) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NPUAllocFloatStatus](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NPUAllocFloatStatus) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NPUGetFloatStatus](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NPUGetFloatStatus) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NPUClearFloatStatus](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NPUClearFloatStatus) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.FloatStatus](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloatStatus) | Doing | Supported | Doing | math_ops
+| [mindspore.ops.Cos](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cos) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Cosh](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cosh) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ACos](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ACos) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BesselI0e](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BesselI0e) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.BesselI1e](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BesselI1e) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.TruncateDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateDiv) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.TruncateMod](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TruncateMod) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Tan](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tan) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Asin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Asin) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Asinh](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Asinh) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Erf](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Erf) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Erfc](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Erfc) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Sin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sin) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sinh](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sinh) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Expm1](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Expm1) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.NMSWithMask](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NMSWithMask) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Abs](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Abs) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.Sign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sign) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Round](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Round) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ApproximateEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApproximateEqual) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.InplaceAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InplaceAdd) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.InplaceSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InplaceSub) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Mod](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mod) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ExpandDims](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ExpandDims) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.DType](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DType) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.SameTypeShape](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SameTypeShape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Cast](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cast) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.IsSubClass](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IsSubClass) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.IsInstance](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IsInstance) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Reshape](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reshape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Shape](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Shape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Squeeze](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Squeeze) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.Transpose](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Transpose) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.GatherV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherV2) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Split](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Split) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.Rank](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rank) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Size](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Size) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Fill](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Fill) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.OnesLike](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OnesLike) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ZerosLike](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ZerosLike) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.TupleToArray](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TupleToArray) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ScalarToArray](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarToArray) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ScalarToTensor](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarToTensor) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.InvertPermutation](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InvertPermutation) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Argmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Argmax) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Argmin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Argmin) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ArgMaxWithValue](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMaxWithValue) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ArgMinWithValue](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMinWithValue) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Tile](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tile) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.UnsortedSegmentSum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UnsortedSegmentSum) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.UnsortedSegmentMin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UnsortedSegmentMin) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.UnsortedSegmentProd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UnsortedSegmentProd) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Concat](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Concat) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ParallelConcat](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ParallelConcat) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Slice](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Slice) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Select](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Select) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.StridedSlice](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.StridedSlice) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Diag](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Diag) | Doing | Doing | Doing | array_ops
+| [mindspore.ops.DiagPart](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DiagPart) | Doing | Doing | Doing | array_ops
+| [mindspore.ops.Eye](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Eye) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.ScatterNd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNd) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ResizeNearestNeighbor](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ResizeNearestNeighbor) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.GatherNd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherNd) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.ApplyFtrl](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ApplyFtrl) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.SparseApplyFtrl](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrl) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.FusedSparseFtrl](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FusedSparseFtrl) | Doing | Doing | Supported | array_ops
+| [mindspore.ops.SparseApplyFtrlV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseApplyFtrlV2) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNdUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdUpdate) | Supported | Doing | Supported | array_ops
+| [mindspore.ops.ScatterUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterMul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMul) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterDiv) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.SpaceToDepth](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SpaceToDepth) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.DepthToSpace](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DepthToSpace) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.SpaceToBatch](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SpaceToBatch) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.SpaceToBatchND](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SpaceToBatchND) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.BatchToSpace](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchToSpace) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.BatchToSpaceND](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchToSpaceND) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.IsFinite](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IsFinite) | Supported | Supported | Doing | array_ops
+| [mindspore.ops.InplaceUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InplaceUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterSub) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterMax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMax) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterMin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterMin) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNdAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdAdd) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNdSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNdSub) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ScatterNonAliasingAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNonAliasingAdd) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.Rint](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rint) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ReverseV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReverseV2) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.ReduceOp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceOp) | Supported | Supported | Doing | comm_ops
+| [mindspore.ops.AllReduce](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AllReduce) | Supported | Supported | Doing | comm_ops
+| [mindspore.ops.AllGather](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AllGather) | Supported | Supported | Doing | comm_ops
+| [mindspore.ops.ReduceScatter](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceScatter) | Doing | Supported | Doing | comm_ops
+| [mindspore.ops.Broadcast](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Broadcast) | Supported | Doing | Doing | comm_ops
+| [mindspore.ops.ControlDepend](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ControlDepend) | Supported | Supported | Supported | control_ops
+| [mindspore.ops.GeSwitch](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GeSwitch) | Doing | Doing | Doing | control_ops
+| [mindspore.ops.Merge](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Merge) | Doing | Doing | Doing | control_ops
+| [mindspore.ops.ScalarSummary](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.ImageSummary](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ImageSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.TensorSummary](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.HistogramSummary](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HistogramSummary) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.InsertGradientOf](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InsertGradientOf) | Supported | Supported | Supported | debug_ops
+| [mindspore.ops.Print](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Print) | Supported | Doing | Doing | debug_ops
+| [mindspore.ops.Assign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Assign) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.BoundingBoxEncode](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BoundingBoxEncode) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.BoundingBoxDecode](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BoundingBoxDecode) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.PopulationCount](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.PopulationCount) | Supported | Doing | Doing | other_ops
+| [mindspore.ops.CheckValid](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CheckValid) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.IOU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IOU) | Supported | Supported | Doing | other_ops
+| [mindspore.ops.MakeRefKey](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MakeRefKey) | Supported | Supported | Supported | other_ops
+| [mindspore.ops.InTopK](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.InTopK) | Supported | Doing | Doing | other_ops
+| [mindspore.ops.StandardNormal](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.StandardNormal) | Supported | Supported | Doing | random_ops
+| [mindspore.ops.Gamma](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Gamma) | Supported | Doing | Doing | random_ops
+| [mindspore.ops.Poisson](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Poisson) | Supported | Doing | Doing | random_ops
+| [mindspore.ops.UniformInt](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UniformInt) | Supported | Supported | Doing | random_ops
+| [mindspore.ops.UniformReal](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.UniformReal) | Supported | Supported | Doing | random_ops
+| [mindspore.ops.RandomChoiceWithMask](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RandomChoiceWithMask) | Supported| Supported | Doing | random_ops
+| [mindspore.ops.RandomCategorical](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RandomCategorical) | Supported| Doing | Doing | random_ops
+| [mindspore.ops.ScalarCast](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScalarCast) | Supported | Supported | Supported | inner_ops
+| [mindspore.ops.ReverseSequence](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReverseSequence) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.CropAndResize](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.CropAndResize) | Supported | Doing | Doing | image_ops
+| [mindspore.ops.SquaredDifference](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SquaredDifference) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Xdivy](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xdivy) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Xlogy](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Xlogy) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.HistogramFixedWidth](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.HistogramFixedWidth) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.Eps](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Eps) | Supported | Supported | Doing | math_ops
+| [mindspore.ops.ReLUV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLUV2) | Supported | Supported | Supported | nn_ops
+| [mindspore.ops.BNTrainingReduce](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BNTrainingReduce) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.BNTrainingUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BNTrainingUpdate) | Supported | Doing | Doing | nn_ops
+| [mindspore.ops.AccumulateNV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AccumulateNV2) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.ScatterUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.TensorScatterUpdate](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorScatterUpdate) | Supported | Doing | Doing | array_ops
+| [mindspore.ops.IFMR](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.IFMR) | Supported | Doing | Doing | math_ops
+| [mindspore.ops.DynamicShape](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DynamicShape) | Supported | Supported | Supported | array_ops
+| [mindspore.ops.Unique](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Unique) | Doing | Doing | Doing | array_ops
+
+## mindspore.ops.functional
+
+| 操作名 | 对应functional算子
+| :----------- | :-----------
+| [mindspore.ops.Pack](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pack) | pack
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd) | tensor_add
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub) | assign_sub
+| [mindspore.ops.AddN](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AddN) | addn
+| [mindspore.ops.Square](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Square) | square
+| [mindspore.ops.Sqrt](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sqrt) | sqrt
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal) | equal
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual) | not_equal
+| [mindspore.ops.LogicalNot](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalNot) | logical_not
+| [mindspore.ops.LogicalAnd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalAnd) | logical_and
+| [mindspore.ops.LogicalOr](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalOr) | logical_or
+| [mindspore.ops.ExpandDims](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ExpandDims) | expand_dims
+| [mindspore.ops.DType](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DType) | dtype
+| [mindspore.ops.Cast](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cast) | cast
+| [mindspore.ops.Reshape](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reshape) | reshape
+| [mindspore.ops.Shape](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Shape) | shape
+| [mindspore.ops.GatherV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherV2) | gather
+| [mindspore.ops.Rank](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Rank) | rank
+| [mindspore.ops.Size](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Size) | size
+| [mindspore.ops.Fill](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Fill) | fill
+| [mindspore.ops.OnesLike](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OnesLike) | ones_like
+| [mindspore.ops.Tile](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tile) | tile
+| [mindspore.ops.Select](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Select) | select
+| [mindspore.ops.ScatterNd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ScatterNd) | scatter_nd
+| [mindspore.ops.GatherNd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherNd) | gather_nd
+| [mindspore.ops.ControlDepend](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ControlDepend) | control_depend
+| [mindspore.ops.Print](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Print) | print
+| [mindspore.ops.Assign](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Assign) | assign
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow) | tensor_pow
+
+> 当前functional支持了一部分没有属性的算子，后续会进一步补齐完整。
diff --git a/docs/note/source_zh_cn/operator_list_parallel.md b/docs/note/source_zh_cn/operator_list_parallel.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb35a6bc8ad14b69e37a484785ceac24b5ce2166
--- /dev/null
+++ b/docs/note/source_zh_cn/operator_list_parallel.md
@@ -0,0 +1,74 @@
+# MindSpore分布式算子支持
+
+`Linux` `Ascend` `GPU` `CPU` `模型开发` `初级` `中级` `高级`
+
+
+
+- [MindSpore分布式算子支持](#mindspore分布式算子支持)
+ - [分布式算子](#分布式算子)
+
+
+
+
+
+## 分布式算子
+
+| 操作名 | 约束
+| :----------- | :-----------
+| [mindspore.ops.ACos](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ACos) | None
+| [mindspore.ops.Cos](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cos) | None
+| [mindspore.ops.LogicalNot](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogicalNot) | None
+| [mindspore.ops.Log](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Log) | None
+| [mindspore.ops.Exp](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Exp) | None
+| [mindspore.ops.LogSoftmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.LogSoftmax) | 输入（logits）在轴（axis）对应的维度不可切分，切分后，在数学逻辑上和单机不等价
+| [mindspore.ops.Softmax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Softmax) | 输入（logits）在轴（axis）对应的维度不可切分，切分后，在数学逻辑上和单机不等价
+| [mindspore.ops.Tanh](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tanh) | None
+| [mindspore.ops.Gelu](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Gelu) | None
+| [mindspore.ops.ReLU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReLU) | None
+| [mindspore.ops.Sqrt](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sqrt) | None
+| [mindspore.ops.Cast](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Cast) | None
+| [mindspore.ops.Neg](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Neg) | None
+| [mindspore.ops.ExpandDims](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ExpandDims) | None
+| [mindspore.ops.Squeeze](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Squeeze) | None
+| [mindspore.ops.Square](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Square) | None
+| [mindspore.ops.Sigmoid](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sigmoid) | None
+| [mindspore.ops.Dropout](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Dropout) | 不支持重复计算
+| [mindspore.ops.Div](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Div) | None
+| [mindspore.ops.TensorAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.TensorAdd) | None
+| [mindspore.ops.RealDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.RealDiv) | None
+| [mindspore.ops.Mul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Mul) | None
+| [mindspore.ops.Sub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Sub) | None
+| [mindspore.ops.Pow](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Pow) | None
+| [mindspore.ops.FloorDiv](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.FloorDiv) | None
+| [mindspore.ops.Greater](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Greater) | None
+| [mindspore.ops.AssignSub](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.AssignSub) | None
+| [mindspore.ops.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SigmoidCrossEntropyWithLogits) | None
+| [mindspore.ops.Equal](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Equal) | None
+| [mindspore.ops.NotEqual](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.NotEqual) | None
+| [mindspore.ops.Maximum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Maximum) | None
+| [mindspore.ops.Minimum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Minimum) | None
+| [mindspore.ops.BiasAdd](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BiasAdd) | None
+| [mindspore.ops.Concat](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Concat) | 输入（input_x）在轴（axis）所对应的维度不能切分，切分后，在数学逻辑上和单机不等价
+| [mindspore.ops.DropoutGenMask](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutGenMask) | 需和`DropoutDoMask`联合使用
+| [mindspore.ops.DropoutDoMask](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.DropoutDoMask) | 需和`DropoutGenMask`联合使用，不支持配置切分策略
+| [mindspore.ops.GatherV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GatherV2) | 仅支持1维和2维的input_params，并且input_params的最后一维要32字节对齐（出于性能考虑）；不支持标量input_indices；参数在轴（axis）所在维度切分时，不支持重复计算；不支持input_indices和input_params同时进行切分
+| [mindspore.ops.SparseGatherV2](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SparseGatherV2) | 同GatherV2
+| [mindspore.ops.EmbeddingLookup](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.EmbeddingLookup) | 同GatherV2
+| [mindspore.ops.L2Normalize](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.L2Normalize) | 输入（input_x）在轴（axis）对应的维度不能切，切分后，在数学逻辑上和单机不等价
+| [mindspore.ops.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.SoftmaxCrossEntropyWithLogits) | 输入（logits、labels）的最后一维不能切分；有两个输出，正向的loss只支持取[0]
+| [mindspore.ops.MatMul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.MatMul) | 不支持`transpose_a=True`
+| [mindspore.ops.BatchMatMul](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.BatchMatMul) | 不支持`transpore_a=True`
+| [mindspore.ops.PReLU](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.PReLU) | weight的shape在非[1]的情况下，输入（input_x）的Channel维要和weight的切分方式一致
+| [mindspore.ops.OneHot](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.OneHot) | 仅支持输入（indices）是1维的Tensor，切分策略要配置输出的切分策略，以及第1和第2个输入的切分策略
+| [mindspore.ops.ReduceSum](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceSum) | None
+| [mindspore.ops.ReduceMax](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMax) | 输入在轴（axis）的维度进行切分时，分布式结果可能会和单机不一致
+| [mindspore.ops.ReduceMin](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMin) | 输入在轴（axis）的维度进行切分时，分布式结果可能会和单机不一致
+| [mindspore.ops.ArgMinWithValue](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMinWithValue) | 输入在轴（axis）的维度进行切分时，分布式结果可能会和单机不一致
+| [mindspore.ops.ArgMaxWithValue](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ArgMaxWithValue) | 输入在轴（axis）的维度进行切分时，分布式结果可能会和单机不一致
+| [mindspore.ops.ReduceMean](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.ReduceMean) | None
+| [mindspore.ops.Reshape](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Reshape) | 不支持配置切分策略
+| [mindspore.ops.StridedSlice](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.StridedSlice) | 仅支持值为全0的mask；需要切分的维度必须全部提取；输入在strides不为1对应的维度不支持切分
+| [mindspore.ops.Tile](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Tile) | 仅支持对multiples配置切分策略
+| [mindspore.ops.Transpose](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.Transpose) | None
+
+> 重复计算是指，机器没有用满，比如：集群有8张卡跑分布式训练，切分策略只对输入切成了4份。这种情况下会发生重复计算。
diff --git a/docs/source_zh_cn/roadmap.md b/docs/note/source_zh_cn/roadmap.md
similarity index 43%
rename from docs/source_zh_cn/roadmap.md
rename to docs/note/source_zh_cn/roadmap.md
index 6b24fdc3e17857d8f5612e808f8ba8b218ee3d5e..5e9bff7a210752780c8aa09398a58263c0eff420 100644
--- a/docs/source_zh_cn/roadmap.md
+++ b/docs/note/source_zh_cn/roadmap.md
@@ -1,4 +1,4 @@
-# RoadMap
+# 路标
`Linux` `Windows` `Ascend` `GPU` `CPU` `全流程` `框架开发` `中级` `高级` `贡献者`
@@ -15,11 +15,12 @@
-
+
以下将展示MindSpore近一年的高阶计划，我们会根据用户的反馈诉求，持续调整计划的优先级。
总体而言，我们会努力在以下几个方面不断改进。
+
1. 提供更多的预置模型支持。
2. 持续补齐API和算子库，改善易用性和编程体验。
3. 提供华为昇腾AI处理器的全面支持，并不断优化性能及软件架构。
@@ -28,56 +29,63 @@
热忱希望各位在用户社区加入讨论，并贡献您的建议。
## 预置模型
-* CV：目标检测、GAN、图像分割、姿态识别等场景经典模型。
-* NLP：RNN、Transformer类型神经网络，拓展基于Bert预训练模型的应用。
-* 其它：GNN、强化学习、概率编程、AutoML等。
+
+- CV：目标检测、GAN、图像分割、姿态识别等场景经典模型。
+- NLP：RNN、Transformer类型神经网络，拓展基于Bert预训练模型的应用。
+- 其它：GNN、强化学习、概率编程、AutoML等。
## 易用性
-* 补齐算子、优化器、Loss函数等各类API
-* 完善Python语言原生表达支持
-* 支持常见的Tensor/Math操作
-* 增加更多的自动并行适用场景，提高策略搜索的准确性
+
+- 补齐算子、优化器、Loss函数等各类API
+- 完善Python语言原生表达支持
+- 支持常见的Tensor/Math操作
+- 增加更多的自动并行适用场景，提高策略搜索的准确性
## 性能优化
-* 优化编译时间
-* 低比特混合精度训练/推理
-* 提升内存使用效率
-* 提供更多的融合优化手段
-* 加速PyNative执行性能
+
+- 优化编译时间
+- 低比特混合精度训练/推理
+- 提升内存使用效率
+- 提供更多的融合优化手段
+- 加速PyNative执行性能
## 架构演进
-* 图算融合优化：使用细粒度Graph IR表达算子，构成带算子边界的中间表达，挖掘更多图层优化机会。
-* 支持更多编程语言
-* 优化数据增强的自动调度及分布式训练数据缓存机制
-* 持续完善MindSpore IR
-* Parameter Server模式分布式训练
+
+- 图算融合优化：使用细粒度Graph IR表达算子，构成带算子边界的中间表达，挖掘更多图层优化机会。
+- 支持更多编程语言
+- 优化数据增强的自动调度及分布式训练数据缓存机制
+- 持续完善MindSpore IR
+- Parameter Server模式分布式训练
## MindInsight调试调优
-* 训练过程观察
- * 直方图
- * 计算图/数据图展示优化
- * 集成性能Profiling/Debugger工具
- * 支持多次训练间的对比
-* 训练结果溯源
- * 数据增强溯源对比
-* 训练过程诊断
- * 性能Profiling
- * 基于图模型的Debugger
+
+- 训练过程观察
+ - 直方图
+ - 计算图/数据图展示优化
+ - 集成性能Profiling/Debugger工具
+ - 支持多次训练间的对比
+- 训练结果溯源
+ - 数据增强溯源对比
+- 训练过程诊断
+ - 性能Profiling
+ - 基于图模型的Debugger
## MindArmour安全增强包
-* 测试模型的安全性
-* 提供模型安全性增强工具
-* 保护训练和推理过程中的数据隐私
+
+- 测试模型的安全性
+- 提供模型安全性增强工具
+- 保护训练和推理过程中的数据隐私
## 推理框架
-* 算子性能与完备度的持续优化
-* 支持语音模型推理
-* 端侧模型的可视化
-* Micro方案，适用于嵌入式系统的超轻量化推理， 支持ARM Cortex-A、Cortex-M硬件
-* 支持端侧重训及联邦学习
-* 端侧自动并行特性
-* 端侧MindData，包含图片Resize、像素数据转换等功能
-* 配套MindSpore混合精度量化训练（或训练后量化），实现混合精度推理，提升推理性能
-* 支持Kirin NPU、MTK APU等AI加速硬件
-* 支持多模型推理pipeline
-* C++构图接口
+
+- 算子性能与完备度的持续优化
+- 支持语音模型推理
+- 端侧模型的可视化
+- Micro方案，适用于嵌入式系统的超轻量化推理， 支持ARM Cortex-A、Cortex-M硬件
+- 支持端侧重训及联邦学习
+- 端侧自动并行特性
+- 端侧MindData，包含图片Resize、像素数据转换等功能
+- 配套MindSpore混合精度量化训练（或训练后量化），实现混合精度推理，提升推理性能
+- 支持Kirin NPU、MTK APU等AI加速硬件
+- 支持多模型推理pipeline
+- C++构图接口
diff --git a/docs/programming_guide/Makefile b/docs/programming_guide/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..1eff8952707bdfa503c8d60c1e9a903053170ba2
--- /dev/null
+++ b/docs/programming_guide/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS ?=
+SPHINXBUILD ?= sphinx-build
+SOURCEDIR = source_zh_cn
+BUILDDIR = build_zh_cn
+
+# Put it first so that "make" without argument is like "make help".
+help:
+ @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+ @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/docs/programming_guide/requirements.txt b/docs/programming_guide/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..162b50040286bb9a0177801c580a31013082a360
--- /dev/null
+++ b/docs/programming_guide/requirements.txt
@@ -0,0 +1,6 @@
+sphinx >= 2.2.1, <= 2.4.4
+recommonmark
+sphinx-markdown-tables
+sphinx_rtd_theme
+numpy
+jieba
diff --git a/docs/programming_guide/source_en/_static/logo_notebook.png b/docs/programming_guide/source_en/_static/logo_notebook.png
new file mode 100644
index 0000000000000000000000000000000000000000..18c2e29e4b73ee428f70253feffdd855fdf0c422
Binary files /dev/null and b/docs/programming_guide/source_en/_static/logo_notebook.png differ
diff --git a/docs/programming_guide/source_en/_static/logo_source.png b/docs/programming_guide/source_en/_static/logo_source.png
new file mode 100644
index 0000000000000000000000000000000000000000..880f2bc87172daf487654c0ba4f1657c672bd2b8
Binary files /dev/null and b/docs/programming_guide/source_en/_static/logo_source.png differ
diff --git a/docs/programming_guide/source_en/api_structure.md b/docs/programming_guide/source_en/api_structure.md
new file mode 100644
index 0000000000000000000000000000000000000000..977be3ff3a55a123349bf5965ce61706de63bf05
--- /dev/null
+++ b/docs/programming_guide/source_en/api_structure.md
@@ -0,0 +1,81 @@
+# MindSpore API Overview
+
+
+
+- [MindSpore API Overview](#mindspore-api-overview)
+ - [Overall Architecture](#overall-architecture)
+ - [Design Concept](#design-concept)
+ - [Level Structure](#level-structure)
+
+
+
+
+
+## Overall Architecture
+
+MindSpore is a deep learning framework in all scenarios, aiming to achieve easy development, efficient execution, and all-scenario coverage. Easy development features include API friendliness and low debugging difficulty. Efficient execution includes computing efficiency, data preprocessing efficiency, and distributed training efficiency. All-scenario coverage means that the framework supports cloud, edge, and device scenarios.
+
+The overall architecture of MindSpore consists of the Mind Expression (ME), Graph Engine (GE), and backend runtime. ME provides user-level APIs for scientific computing, building and training neural networks, and converting Python code of users into graphs. GE is a manager of operators and hardware resources, and is responsible for controlling execution of graphs received from ME. Backend runtime includes efficient running environments, such as the CPU, GPU, Ascend AI processors, and Android/iOS, on the cloud, edge, and device. For more information about the overall architecture, see [Overall Architecture](https://www.mindspore.cn/doc/note/en/r1.0/design/mindspore/architecture.html).
+
+## Design Concept
+
+MindSpore originates from the best practices of the entire industry and provides unified model training, inference, and export APIs for data scientists and algorithm engineers. It supports flexible deployment in different scenarios such as the device, edge, and cloud, and promotes the prosperity of domains such as deep learning and scientific computing.
+
+MindSpore provides the Python programming paradigm. Users can use the native control logic of Python to build complex neural network models, simplifying AI programming. For details, see [Implementing an Image Classification Application](https://www.mindspore.cn/tutorial/training/en/r1.0/quick_start/quick_start.html).
+
+Currently, there are two execution modes of a mainstream deep learning framework: a static graph mode and a dynamic graph mode. The static graph mode has a relatively high training performance, but is difficult to debug. On the contrary, the dynamic graph mode is easy to debug, but is difficult to execute efficiently. MindSpore provides an encoding mode that unifies dynamic and static graphs, which greatly improves the compatibility between static and dynamic graphs. Instead of developing multiple sets of code, users can switch between the dynamic and static graph modes by changing only one line of code. For example, set `context.set_context(mode=context.PYNATIVE_MODE)` to switch to the dynamic graph mode, or set `context.set_context(mode=context.GRAPH_MODE)` to switch to the static graph mode, which facilitates development and debugging, and improves performance experience.
+
+A neural network model is usually trained based on gradient descent algorithm, but the manual derivation process is complex and the result is prone to errors. The automatic differentiation mechanism of MindSpore based on source code transformation (SCT) uses a functional differential programming architecture and provides Python APIs at the API layer, including the expression of control flows. Users can focus on the native mathematical expression of the model algorithm without manual derivation. The sample code for automatic differentiation is as follows:
+
+```python
+import mindspore as ms
+from mindspore import ops
+
+
+grad_all = ops.composite.GradOperation()
+
+
+def func(x): return x * x * x
+
+
+def df_func(x):
+ return grad_all(func)(x)
+
+
+@ms.ms_function
+def df2_func(x):
+ return grad_all(df_func)(x)
+
+
+if __name__ == "__main__":
+ print(df2_func(ms.Tensor(2, ms.float32)))
+
+```
+
+In the first step, a function (computational graph) is defined. In the second step, automatic differentiation is performed by using a backward API provided by MindSpore, and the first derivative function (computational graph) is defined. In the third step, the second derivative function (computational graph) is defined. After the input is given, the second derivative of the function defined in step 1 can be obtained at the specified position. The result of the second derivative is `12`.
+
+In addition, the SCT can convert Python code into an intermediate representation (IR) of a MindSpore function. The IR constructs a computational graph that can be parsed and executed on different devices. Before the computational graph is executed, a plurality of software and hardware collaborative optimization technologies are used, and performance and efficiency in different scenarios such as device, edge, and cloud, are improved.
+
+Improving the data processing capability to match the computing power of AI chips is the key to ensure the ultimate performance of AI chips. MindSpore provides multiple data processing operators and uses automatic data acceleration technology to implement high-performance pipelines, including data loading, data demonstration, and data conversion. It supports data processing capabilities in all scenarios, such as CV, NLP, and GNN. MindRecord is a self-developed data format of MindSpore. It features efficient read and write and easy distributed processing. Users can convert non-standard and common datasets to the MindRecord format to obtain better performance experience. MindSpore supports the loading of common datasets and datasets in multiple data storage formats. For example, users can use `dataset=dataset.Cifar10Dataset("Cifar10Data/")` to load the CIFAR-10 dataset. `Cifar10Data/` indicates the local directory of the dataset, and users can also use `GeneratorDataset` to customize the dataset loading mode. Data augmentation is a method of generating new data based on (limited) data, which can reduce the overfitting phenomenon of network model and improve the generalization ability of the model. In addition to user-defined data augmentation, MindSpore provides automatic data augmentation, making data augmentation more flexible.
+
+The deep learning neural network model usually contains many hidden layers for feature extraction. However, the feature extraction is random and the debugging process is invisible, which limits the trustworthiness and optimization of the deep learning technology. MindSpore supports visualized debugging and optimization (MindInsight) and provides functions such as training dashboard, lineage, performance analysis, and debugger to help users detect deviations during model training and easily debug and optimize models. For example, before initializing the network, users can use `profiler=Profiler()` to initialize the `Profiler` object, automatically collect information such as the operator time consumption during training, and record the information in a file. After the training is complete, call `profiler.analyse()` to stop collecting data and generate performance analysis results. Users can view and analyze the visualized results to more efficiently debug network performance. For details about debugging and optimization, see [Training Process Visualization](https://www.mindspore.cn/tutorial/training/en/r1.0/advanced_use/visualization_tutorials.html).
+
+As a scale of neural network models and datasets continuously increases, parallel distributed training becomes a common practice of neural network training. However, policy selection and compilation of parallel distributed training are very complex, which severely restricts training efficiency of a deep learning model and hinders development of deep learning. MindSpore unifies the encoding methods of standalone and distributed training. Developers do not need to write complex distributed policies. Instead, they can implement distributed training by adding a small amount of code to the standalone code. For example, after `context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL)` is set, a cost model can be automatically established, and a better parallel mode can be selected for users. This improves the training efficiency of neural networks, greatly decreases the AI development difficulty, and enables users to quickly implement model ideas. For more information, see [Distributed Training](https://www.mindspore.cn/tutorial/training/en/r1.0/advanced_use/distributed_training_tutorials.html).
+
+## Level Structure
+
+To support network building, entire graph execution, subgraph execution, and single-operator execution, MindSpore provides users with three levels of APIs which are Low-Level Python API, Medium-Level Python API, and High-Level Python API in ascending order.
+
+
+
+- Low-Level Python API
+
+ The first is low-level API, including tensor definition, basic operators, and automatic differential modules. Users can use the low-level API to easily define tensors and perform derivative calculation. For example, users can customize tensors by using the `Tensor` API, and use the `GradOperation` operator in the `ops.composite` module to calculate the derivative of the function at a specified position.
+
+- Medium-Level Python API
+
+ The second is medium-level API which encapsulates low-cost APIs and provides modules such as the network layer, optimizer, and loss function. Users can flexibly build neural networks and control execution processes through the medium-level API to quickly implement model algorithm logic. For example, users can call the `Cell` API to build neural network models and computing logic, add the loss function and optimization methods to the neural network model by using the `loss` module and `Optimizer` API, and use the `dataset` module to process data for model training and eval.
+
+- High-Level Python API
+
+ The third is high-level API. Based on the medium-level API, it provides advanced APIs such as training and inference management, mixed precision training, and debugging and optimization, facilitating users to control the execution process of the entire network and implement training, inference, and optimization of the neural network. For example, users can use the `Model` API, specify the neural network model to be trained and related training settings, train the neural network model, and debug the neural network performance through the `Profiler` API.
diff --git a/docs/programming_guide/source_en/conf.py b/docs/programming_guide/source_en/conf.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1fd767271ac159540440ed65bd0d676163366a9
--- /dev/null
+++ b/docs/programming_guide/source_en/conf.py
@@ -0,0 +1,58 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'MindSpore'
+copyright = '2020, MindSpore'
+author = 'MindSpore'
+
+# The full version, including alpha/beta/rc tags
+release = 'master'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+ 'sphinx_markdown_tables',
+ 'recommonmark',
+]
+
+source_suffix = {
+ '.rst': 'restructuredtext',
+ '.md': 'markdown',
+}
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+pygments_style = 'sphinx'
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages. See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_rtd_theme'
+
+html_static_path = ['_static']
\ No newline at end of file
diff --git a/docs/programming_guide/source_en/images/api_structure.png b/docs/programming_guide/source_en/images/api_structure.png
new file mode 100644
index 0000000000000000000000000000000000000000..3e5b0e20a2e307c1de163e5cf181a4d748642278
Binary files /dev/null and b/docs/programming_guide/source_en/images/api_structure.png differ
diff --git a/lite/docs/source_zh_cn/index.rst b/docs/programming_guide/source_en/index.rst
similarity index 60%
rename from lite/docs/source_zh_cn/index.rst
rename to docs/programming_guide/source_en/index.rst
index 20ecdbb72c0fe01cbc24c674bda6944504c792ff..00b9ec62f55eb9ccc502ccb611ac491710e5fe33 100644
--- a/lite/docs/source_zh_cn/index.rst
+++ b/docs/programming_guide/source_en/index.rst
@@ -1,16 +1,14 @@
.. MindSpore documentation master file, created by
- sphinx-quickstart on Thu Aug 17 10:00:00 2020.
+ sphinx-quickstart on Thu Mar 24 11:00:00 2020.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
-MindSpore端侧文档
-==================
+MindSpore Programming Guide
+=================================
.. toctree::
- :glob:
:maxdepth: 1
- architecture
- apicc/apicc
+ api_structure
+ network_list
operator_list
- glossary
diff --git a/docs/programming_guide/source_en/network_list.rst b/docs/programming_guide/source_en/network_list.rst
new file mode 100644
index 0000000000000000000000000000000000000000..3e7a1bb42a55c77206df43cf0a0817437741decf
--- /dev/null
+++ b/docs/programming_guide/source_en/network_list.rst
@@ -0,0 +1,7 @@
+Network List
+============
+
+.. toctree::
+ :maxdepth: 1
+
+ MindSpore Network List
+
+## 总体架构
+
+MindSpore是一个全场景深度学习框架，旨在实现易开发、高效执行、全场景覆盖三大目标，其中易开发表现为API友好、调试难度低，高效执行包括计算效率、数据预处理效率和分布式训练效率，全场景则指框架同时支持云、边缘以及端侧场景。
+
+MindSpore总体架构分为前端表示层（Mind Expression，ME）、计算图引擎（Graph Engine，GE）和后端运行时三个部分。ME提供了用户级应用软件编程接口（Application Programming Interface，API），用于科学计算以及构建和训练神经网络，并将用户的Python代码转换为数据流图。GE是算子和硬件资源的管理器，负责控制从ME接收的数据流图的执行。后端运行时包含云、边、端上不同环境中的高效运行环境，例如CPU、GPU、Ascend AI处理器、 Android/iOS等。更多总体架构的相关内容请参见[总体架构](https://www.mindspore.cn/doc/note/zh-CN/r1.0/design/mindspore/architecture.html)。
+
+## 设计理念
+
+MindSpore源于全产业的最佳实践，向数据科学家和算法工程师提供了统一的模型训练、推理和导出等接口，支持端、边、云等不同场景下的灵活部署，推动深度学习和科学计算等领域繁荣发展。
+
+MindSpore目前提供了Python编程范式，用户使用Python原生控制逻辑即可构建复杂的神经网络模型，AI编程变得简单，具体示例请参见[实现一个图片分类应用](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/quick_start/quick_start.html)。
+
+目前主流的深度学习框架的执行模式有两种，分别为静态图模式和动态图模式。静态图模式拥有较高的训练性能，但难以调试。动态图模式相较于静态图模式虽然易于调试，但难以高效执行。MindSpore提供了动态图和静态图统一的编码方式，大大增加了静态图和动态图的可兼容性，用户无需开发多套代码，仅变更一行代码便可切换动态图/静态图模式，例如设置`context.set_context(mode=context.PYNATIVE_MODE)`切换成动态图模式，设置`context.set_context(mode=context.GRAPH_MODE)`即可切换成静态图模式，用户可拥有更轻松的开发调试及性能体验。
+
+神经网络模型通常基于梯度下降算法进行训练，但手动求导过程复杂，结果容易出错。MindSpore的基于源码转换（Source Code Transformation，SCT）的自动微分（Automatic Differentiation）机制采用函数式可微分编程架构，在接口层提供Python编程接口，包括控制流的表达。用户可聚焦于模型算法的数学原生表达，无需手动进行求导，自动微分的样例代码如下所示。
+
+```python
+import mindspore as ms
+from mindspore import ops
+
+
+grad_all = ops.composite.GradOperation()
+
+
+def func(x): return x * x * x
+
+
+def df_func(x):
+ return grad_all(func)(x)
+
+
+@ms.ms_function
+def df2_func(x):
+ return grad_all(df_func)(x)
+
+
+if __name__ == "__main__":
+ print(df2_func(ms.Tensor(2, ms.float32)))
+
+```
+
+其中，第一步定义了一个函数（计算图），第二步利用MindSpore提供的反向接口进行自动微分，定义了一个一阶导数函数（计算图），第三步定义了一个二阶导数函数（计算图），最后给定输入就能获取第一步定义的函数在指定处的二阶导数，二阶导数求导结果为`12`。
+
+此外，SCT能够将Python代码转换为MindSpore函数中间表达（Intermediate Representation，IR），该函数中间表达构造出能够在不同设备解析和执行的计算图，并且在执行该计算图前，应用了多种软硬件协同优化技术，端、边、云等不同场景下的性能和效率得到针对性的提升。
+
+如何提高数据处理能力以匹配人工智能芯片的算力，是保证人工智能芯片发挥极致性能的关键。MindSpore为用户提供了多种数据处理算子，通过自动数据加速技术实现了高性能的流水线，包括数据加载、数据论证、数据转换等，支持CV/NLP/GNN等全场景的数据处理能力。MindRecord是MindSpore的自研数据格式，具有读写高效、易于分布式处理等优点，用户可将非标准的数据集和常用的数据集转换为MindRecord格式，从而获得更好的性能体验，转换详情请参见[MindSpore数据格式转换](https://www.mindspore.cn/doc/programming_guide/zh-CN/r1.0/dataset_conversion.html)。MindSpore支持加载常用的数据集和多种数据存储格式下的数据集，例如通过`dataset=dataset.Cifar10Dataset("Cifar10Data/")`即可完成CIFAR-10数据集的加载，其中`Cifar10Data/`为数据集本地所在目录，用户也可通过`GeneratorDataset`自定义数据集的加载方式。数据增强是一种基于（有限）数据生成新数据的方法，能够减少网络模型过拟合的现象，从而提高模型的泛化能力。MindSpore除了支持用户自定义数据增强外，还提供了自动数据增强方式，使得数据增强更加灵活，详情请见[自动数据增强](https://www.mindspore.cn/doc/programming_guide/zh-CN/r1.0/auto_augmentation.html)。
+
+深度学习神经网络模型通常含有较多的隐藏层进行特征提取，但特征提取随机化、调试过程不可视限制了深度学习技术的可信和调优。MindSpore支持可视化调试调优（MindInsight），提供训练看板、溯源、性能分析和调试器等功能，帮助用户发现模型训练过程中出现的偏差，轻松进行模型调试和性能调优。例如用户可在初始化网络前，通过`profiler=Profiler()`初始化`Profiler`对象，自动收集训练过程中的算子耗时等信息并记录到文件中，在训练结束后调用`profiler.analyse()`停止收集并生成性能分析结果，以可视化形式供用户查看分析，从而更高效地调试网络性能，更多调试调优相关内容请见[训练过程可视化](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/visualization_tutorials.html)。
+
+随着神经网络模型和数据集的规模不断增加，分布式并行训练成为了神经网络训练的常见做法，但分布式并行训练的策略选择和编写十分复杂，这严重制约着深度学习模型的训练效率，阻碍深度学习的发展。MindSpore统一了单机和分布式训练的编码方式，开发者无需编写复杂的分布式策略，在单机代码中添加少量代码即可实现分布式训练，例如设置`context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL)`便可自动建立代价模型，为用户选择一种较优的并行模式，提高神经网络训练效率，大大降低了AI开发门槛，使用户能够快速实现模型思路，更多内容请见[分布式并行训练](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/distributed_training_tutorials.html)。
+
+## 层次结构
+
+MindSpore向用户提供了3个不同层次的API，支撑用户进行网络构建、整图执行、子图执行以及单算子执行，从低到高分别为Low-Level Python API、Medium-Level Python API以及High-Level Python API。
+
+
+
+- Low-Level Python API
+
+ 第一层为低阶API，主要包括张量定义、基础算子、自动微分等模块，用户可使用低阶API轻松实现张量定义和求导计算，例如用户可通过`Tensor`接口自定义张量，使用`ops.composite`模块下的`GradOperation`算子计算函数在指定处的导数。
+
+- Medium-Level Python API
+
+ 第二层为中阶API，其封装了低价API，提供网络层、优化器、损失函数等模块，用户可通过中阶API灵活构建神经网络和控制执行流程，快速实现模型算法逻辑，例如用户可调用`Cell`接口构建神经网络模型和计算逻辑，通过使用`loss`模块和`Optimizer`接口为神经网络模型添加损失函数和优化方式，利用`dataset`模块对数据进行处理以供模型的训练和推导使用。
+
+- High-Level Python API
+
+ 第三层为高阶API，其在中阶API的基础上又提供了训练推理的管理、混合精度训练、调试调优等高级接口，方便用户控制整网的执行流程和实现神经网络的训练推理及调优，例如用户使用`Model`接口，指定要训练的神经网络模型和相关的训练设置，对神经网络模型进行训练，通过`Profiler`接口调试神经网络性能。
diff --git a/api/source_zh_cn/programming_guide/augmentation.md b/docs/programming_guide/source_zh_cn/augmentation.md
similarity index 53%
rename from api/source_zh_cn/programming_guide/augmentation.md
rename to docs/programming_guide/source_zh_cn/augmentation.md
index 74fd8b0ba812a83678302bdedf5be17cea0ea403..4ba64e0a1e30a830de96f5dec6e938cf25b61e20 100644
--- a/api/source_zh_cn/programming_guide/augmentation.md
+++ b/docs/programming_guide/source_zh_cn/augmentation.md
@@ -10,26 +10,26 @@
- [Resize](#resize)
- [Invert](#invert)
- [py_transforms](#py_transforms)
- - [ComposeOp](#composeop)
+ - [Compose](#compose)
- [使用说明](#使用说明)
+ - [参考文献](#参考文献)
-
+
## 概述
在计算机视觉任务中，数据量过小或是样本场景单一等问题都会影响模型的训练效果，用户可以通过数据增强操作对图像进行预处理，从而提升模型的泛化性。
-MindSpore提供了c_transforms模块和py_transforms模块供用户进行数据增强操作，用户也可以自定义函数或者算子进行数据增强。
-
-MindSpore目前支持的常用数据增强算子如下表所示，更多数据增强算子参见[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.vision.html)。
+MindSpore提供了`c_transforms`模块和`py_transforms`模块供用户进行数据增强操作，用户也可以自定义函数或者算子进行数据增强。
| 模块 | 实现 | 说明 |
| ---- | ---- | ---- |
| c_transforms | 基于C++的OpenCV实现 | 具有较高的性能。 |
-| py_transforms | 基于Python的PIL实现 | 该模块提供了多种图像增强功能，并提供了PIL Image和numpy数组之间的传输方法。|
+| py_transforms | 基于Python的PIL实现 | 该模块提供了多种图像增强功能，并提供了PIL Image和NumPy数组之间的传输方法。|
+MindSpore目前支持的常用数据增强算子如下表所示，更多数据增强算子参见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.dataset.vision.html)。
| 模块 | 算子 | 说明 |
| ---- | ---- | ---- |
@@ -40,46 +40,56 @@ MindSpore目前支持的常用数据增强算子如下表所示，更多数据
| py_transforms | RandomCrop | 在图像随机位置裁剪指定大小子图像。 |
| | Resize | 将图像缩放到指定大小。 |
| | Invert | 将图像进行反相。 |
-| |ComposeOp | 将列表中的数据增强操作依次执行。 |
+| |Compose | 将列表中的数据增强操作依次执行。 |
-## c_transforms
+## c_transforms
-下面将简要介绍几种常用的c_transforms模块数据增强算子的使用方法，更多的c_transforms模块数据增强算子参见[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.vision.html#module-mindspore.dataset.vision.c_transforms)。
+下面将简要介绍几种常用的`c_transforms`模块数据增强算子的使用方法。
### RandomCrop
对输入图像进行在随机位置的裁剪。
**参数说明：**
-- *size: 裁剪图像的尺寸。*
-- *padding: 填充的像素数量。*
-- *pad_if_needed: 原图小于裁剪尺寸时，是否需要填充。*
-- *fill_value: 在常量填充模式时使用的填充值。*
-- *padding_mode: 填充模式。*
-```python
-# 对输入图像进行在随机位置的裁剪
+- `size`：裁剪图像的尺寸。
+- `padding`：填充的像素数量。
+- `pad_if_needed`：原图小于裁剪尺寸时，是否需要填充。
+- `fill_value`：在常量填充模式时使用的填充值。
+- `padding_mode`：填充模式。
+
+下面的样例首先使用顺序采样器加载CIFAR-10数据集[1]，然后对已加载的图片进行长宽均为10的随机裁剪，最后输出裁剪前后的图片形状及对应标签，并对图片进行了展示。
+
+下载[CIFAR-10数据集](https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz)并解压，目录结构如下。
+
+```text
+└─cifar-10-batches-bin
+ ├── batches.meta.txt
+ ├── data_batch_1.bin
+ ├── data_batch_2.bin
+ ├── data_batch_3.bin
+ ├── data_batch_4.bin
+ ├── data_batch_5.bin
+ ├── readme.html
+ └── test_batch.bin
+```
+```python
import matplotlib.pyplot as plt
import mindspore.dataset as ds
-import mindspore.dataset.transforms.vision.c_transforms as c_trans
+import mindspore.dataset.vision.c_transforms as c_trans
-# 下载Cifar10数据集，将其解压到Cifar10Data目录
-DATA_DIR = "../data/dataset/testCifar10Data2"
+ds.config.set_seed(5)
+ds.config.set_num_parallel_workers(1)
-# 指定一个顺序采样器SequentialSampler，按照读取顺序获取3个样本数据
-sampler = ds.SequentialSampler(num_samples=3)
+DATA_DIR = "cifar-10-batches-bin/"
-# 使用Cifar10Dataset读取数据集，指定sampler为上述采样器
+sampler = ds.SequentialSampler(num_samples=3)
dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 创建一个随机裁剪算子，裁剪后的长宽分为10个像素
random_crop = c_trans.RandomCrop([10, 10])
+dataset2 = dataset1.map(operations=random_crop, input_columns=["image"])
-# 使用map算子将其作用到数据管道的数据集中
-dataset2 = dataset1.map(input_columns=["image"], operations=random_crop)
-
-# 启动数据管道，输出3个样本数据
image_list1, label_list1 = [], []
image_list2, label_list2 = [], []
for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_iterator()):
@@ -89,33 +99,37 @@ for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_it
image_list2.append(data2['image'])
label_list2.append(data2['label'])
print("Cropped image Shape:", data2['image'].shape, ", Cropped label:", data2['label'])
- print("")
+ print("------")
-# 将原图与裁剪后的图可视化
num_samples = len(image_list1) + len(image_list2)
for i in range(num_samples):
if i < len(image_list1):
plt.subplot(2, len(image_list1), i + 1)
- plt.imshow(image_list1[i])
- plt.title(label_list1[i])
+ plt.imshow(image_list1[i].asnumpy())
+ plt.title(label_list1[i].asnumpy())
else:
plt.subplot(2, len(image_list2), i + 1)
- plt.imshow(image_list2[i % len(image_list2)])
- plt.title(label_list2[i % len(image_list2)])
+ plt.imshow(image_list2[i % len(image_list2)].asnumpy())
+ plt.title(label_list2[i % len(image_list2)].asnumpy())
plt.show()
```
-```
+输出结果如下：
+
+```text
Source image Shape : (32, 32, 3) , Source label : 6
Cropped image Shape: (10, 10, 3) , Cropped label: 6
-
+------
Source image Shape : (32, 32, 3) , Source label : 9
Cropped image Shape: (10, 10, 3) , Cropped label: 9
-
+------
Source image Shape : (32, 32, 3) , Source label : 9
Cropped image Shape: (10, 10, 3) , Cropped label: 9
+------
```
+图片展示如下：
+
### RandomHorizontalFlip
@@ -123,34 +137,29 @@ Cropped image Shape: (10, 10, 3) , Cropped label: 9
对输入图像进行随机水平翻转。
**参数说明：**
-- *prob: 单张图片发生翻转的概率。*
-```python
-# 对输入图像进行随机水平翻转
+- `prob`: 单张图片发生翻转的概率。
+
+下面的样例首先使用随机采样器加载CIFAR-10数据集[1]，然后对已加载的图片进行概率为0.8的随机水平翻转，最后输出翻转前后的图片形状及对应标签，并对图片进行了展示。
+
+依照上文步骤下载CIFAR-10数据集并按要求存放。
+```python
import matplotlib.pyplot as plt
import mindspore.dataset as ds
-import mindspore.dataset.transforms.vision.c_transforms as c_trans
+import mindspore.dataset.vision.c_transforms as c_trans
-# 设置全局随机种子
ds.config.set_seed(6)
+ds.config.set_num_parallel_workers(1)
-# 下载Cifar10数据集，将其解压到Cifar10Data目录
-DATA_DIR = "../data/dataset/testCifar10Data2"
+DATA_DIR = "cifar-10-batches-bin/"
-# 指定一个随机采样器RandomSampler，按照读取顺序获取4个样本数据
sampler = ds.RandomSampler(num_samples=4)
-
-# 使用Cifar10Dataset读取数据集，指定sampler为上述采样器
dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 创建一个随机翻转算子，设置翻转概率为0.8
random_horizontal_flip = c_trans.RandomHorizontalFlip(prob=0.8)
+dataset2 = dataset1.map(operations=random_horizontal_flip, input_columns=["image"])
-# 使用map算子将其作用到数据管道的数据集中
-dataset2 = dataset1.map(input_columns=["image"], operations=random_horizontal_flip)
-
-# 启动数据管道，输出4个样本数据
image_list1, label_list1 = [], []
image_list2, label_list2 = [], []
for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_iterator()):
@@ -160,36 +169,40 @@ for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_it
image_list2.append(data2['image'])
label_list2.append(data2['label'])
print("Flipped image Shape:", data2['image'].shape, ", Flipped label:", data2['label'])
- print("")
+ print("------")
-# 将原图与裁剪后的图可视化
num_samples = len(image_list1) + len(image_list2)
for i in range(num_samples):
if i < len(image_list1):
plt.subplot(2, len(image_list1), i + 1)
- plt.imshow(image_list1[i])
- plt.title(label_list1[i])
+ plt.imshow(image_list1[i].asnumpy())
+ plt.title(label_list1[i].asnumpy())
else:
plt.subplot(2, len(image_list2), i + 1)
- plt.imshow(image_list2[i % len(image_list2)])
- plt.title(label_list2[i % len(image_list2)])
+ plt.imshow(image_list2[i % len(image_list2)].asnumpy())
+ plt.title(label_list2[i % len(image_list2)].asnumpy())
plt.show()
```
-```
+输出结果如下：
+
+```text
Source image Shape : (32, 32, 3) , Source label : 3
Flipped image Shape: (32, 32, 3) , Flipped label: 3
-
+------
Source image Shape : (32, 32, 3) , Source label : 6
Flipped image Shape: (32, 32, 3) , Flipped label: 6
-
+------
Source image Shape : (32, 32, 3) , Source label : 6
Flipped image Shape: (32, 32, 3) , Flipped label: 6
-
+------
Source image Shape : (32, 32, 3) , Source label : 9
Flipped image Shape: (32, 32, 3) , Flipped label: 9
+------
```
+图片展示如下：
+
### Resize
@@ -197,29 +210,32 @@ Flipped image Shape: (32, 32, 3) , Flipped label: 9
对输入图像进行缩放。
**参数说明：**
-- *self: 缩放的目标大小。*
-- *interpolation: 缩放时采用的插值方式。*
-```python
-# 对输入图像进行指定大小缩放
+- `self`：缩放的目标大小。
+- `interpolation`：缩放时采用的插值方式。
+
+下面的样例首先加载MNIST数据集[2]，然后将已加载的图片缩放至(101, 101)大小，最后输出缩放前后的图片形状及对应标签，并对图片进行了展示。
+
+下载MNIST数据集的训练[图像](http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz)和[标签](http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz)并解压，存放在`./MNIST`路径中，目录结构如下。
+```text
+└─MNIST
+ ├─train-images.idx3-ubyte
+ └─train-labels.idx1-ubyte
+```
+
+```python
import matplotlib.pyplot as plt
import mindspore.dataset as ds
-import mindspore.dataset.transforms.vision.c_transforms as c_trans
+import mindspore.dataset.vision.c_transforms as c_trans
-# 下载MNIST数据集，将其解压到MnistData目录
-DATA_DIR = "../data/dataset/testMnistData2"
+DATA_DIR = "MNIST/"
-# 使用MnistDataset读取数据集
dataset1 = ds.MnistDataset(DATA_DIR, num_samples=4, shuffle=False)
-# 创建一个缩放算子，将MNIST的图片从(28, 28)缩放到(101, 101)
resize = c_trans.Resize(size=[101, 101])
+dataset2 = dataset1.map(operations=resize, input_columns=["image"])
-# 使用map算子将其作用到数据管道的数据集中
-dataset2 = dataset1.map(input_columns=["image"], operations=resize)
-
-# 启动数据管道
image_list1, label_list1 = [], []
image_list2, label_list2 = [], []
for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_iterator()):
@@ -229,68 +245,65 @@ for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_it
image_list2.append(data2['image'])
label_list2.append(data2['label'])
print("Flipped image Shape:", data2['image'].shape, ", Flipped label:", data2['label'])
- print("")
+ print("------")
-# 将原图与裁剪后的图可视化
num_samples = len(image_list1) + len(image_list2)
for i in range(num_samples):
if i < len(image_list1):
plt.subplot(2, len(image_list1), i + 1)
- plt.imshow(image_list1[i].squeeze(), cmap=plt.cm.gray)
- plt.title(label_list1[i])
+ plt.imshow(image_list1[i].asnumpy().squeeze(), cmap=plt.cm.gray)
+ plt.title(label_list1[i].asnumpy())
else:
plt.subplot(2, len(image_list2), i + 1)
- plt.imshow(image_list2[i % len(image_list2)].squeeze(), cmap=plt.cm.gray)
- plt.title(label_list2[i % len(image_list2)])
+ plt.imshow(image_list2[i % len(image_list2)].asnumpy().squeeze(), cmap=plt.cm.gray)
+ plt.title(label_list2[i % len(image_list2)].asnumpy())
plt.show()
```
-```
+输出结果如下：
+
+```text
Source image Shape : (28, 28, 1) , Source label : 5
Flipped image Shape: (101, 101, 1) , Flipped label: 5
-
+------
Source image Shape : (28, 28, 1) , Source label : 0
Flipped image Shape: (101, 101, 1) , Flipped label: 0
-
+------
Source image Shape : (28, 28, 1) , Source label : 4
Flipped image Shape: (101, 101, 1) , Flipped label: 4
-
+------
Source image Shape : (28, 28, 1) , Source label : 1
Flipped image Shape: (101, 101, 1) , Flipped label: 1
+------
```
+图片展示如下：
+
### Invert
对输入图像进行反相处理。
-```python
-# 对输入图像进行反相处理
+下面的样例首先加载CIFAR-10数据集[1]，然后同时定义缩放和反相操作并作用于已加载的图片，最后输出缩放与反相前后的图片形状及对应标签，并对图片进行了展示。
+依照上文步骤下载CIFAR-10数据集并按要求存放。
+
+```python
import matplotlib.pyplot as plt
import mindspore.dataset as ds
-import mindspore.dataset.transforms.vision.c_transforms as c_trans
+import mindspore.dataset.vision.c_transforms as c_trans
-# 设置全局随机种子
ds.config.set_seed(8)
-# 下载Cifar10数据集，将其解压到Cifar10Data目录
-DATA_DIR = "../data/dataset/testCifar10Data2"
+DATA_DIR = "cifar-10-batches-bin/"
-# 使用Cifar10Dataset读取数据集
dataset1 = ds.Cifar10Dataset(DATA_DIR, num_samples=4, shuffle=True)
-# 创建一个缩放算子，将图片缩放到(101, 101)
resize = c_trans.Resize(size=[101, 101])
-
-# 创建一个反相算子
invert = c_trans.Invert()
+dataset2 = dataset1.map(operations=[resize, invert], input_columns=["image"])
-# 使用map算子将其作用到数据管道的数据集中(两个算子按顺序起作用)
-dataset2 = dataset1.map(input_columns=["image"], operations=[resize, invert])
-
-# 启动数据管道
image_list1, label_list1 = [], []
image_list2, label_list2 = [], []
for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_iterator()):
@@ -300,121 +313,136 @@ for data1, data2 in zip(dataset1.create_dict_iterator(), dataset2.create_dict_it
image_list2.append(data2['image'])
label_list2.append(data2['label'])
print("Flipped image Shape:", data2['image'].shape, ", Flipped label:", data2['label'])
- print("")
+ print("------")
-# 将原图与裁剪后的图可视化
num_samples = len(image_list1) + len(image_list2)
for i in range(num_samples):
if i < len(image_list1):
plt.subplot(2, len(image_list1), i + 1)
- plt.imshow(image_list1[i].squeeze(), cmap=plt.cm.gray)
- plt.title(label_list1[i])
+ plt.imshow(image_list1[i].asnumpy().squeeze(), cmap=plt.cm.gray)
+ plt.title(label_list1[i].asnumpy())
else:
plt.subplot(2, len(image_list2), i + 1)
- plt.imshow(image_list2[i % len(image_list2)].squeeze(), cmap=plt.cm.gray)
- plt.title(label_list2[i % len(image_list2)])
+ plt.imshow(image_list2[i % len(image_list2)].asnumpy().squeeze(), cmap=plt.cm.gray)
+ plt.title(label_list2[i % len(image_list2)].asnumpy())
plt.show()
```
-```
+输出结果如下：
+
+```text
Source image Shape : (32, 32, 3) , Source label : 4
Flipped image Shape: (32, 32, 3) , Flipped label: 4
-
+------
Source image Shape : (32, 32, 3) , Source label : 9
Flipped image Shape: (32, 32, 3) , Flipped label: 9
-
+------
Source image Shape : (32, 32, 3) , Source label : 6
Flipped image Shape: (32, 32, 3) , Flipped label: 6
-
+------
Source image Shape : (32, 32, 3) , Source label : 5
Flipped image Shape: (32, 32, 3) , Flipped label: 5
+------
```
+图片展示如下：
+
## py_transforms
-下面将简要介绍几种常用的py_transforms模块数据增强算子的使用方法，更多的py_transforms模块数据增强算子参见[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.vision.html#module-mindspore.dataset.vision.py_transforms)。
+下面将简要介绍几种常用的`py_transforms`模块数据增强算子的使用方法。
-### ComposeOp
+### Compose
-```python
-# 对输入图像进行解码，缩放组合操作
+接收一个`transforms`列表，将列表中的数据增强操作依次作用于数据集图片。
+下面的样例首先加载CIFAR-10数据集[1]，然后同时定义解码、缩放和数据类型转换操作，并作用于已加载的图片，最后输出处理后的图片形状及对应标签，并对图片进行了展示。
+
+依照上文步骤下载CIFAR-10数据集并按要求存放。
+
+```python
import matplotlib.pyplot as plt
import mindspore.dataset as ds
-import mindspore.dataset.transforms.vision.py_transforms as py_trans
+import mindspore.dataset.vision.py_transforms as py_trans
+from mindspore.dataset.transforms.py_transforms import Compose
+from PIL import Image
-# 设置全局随机种子
ds.config.set_seed(8)
-# 图像数据集目录
-DATA_DIR = "../data/dataset/testPK/data"
+DATA_DIR = "cifar-10-batches-bin/"
+
+dataset1 = ds.Cifar10Dataset(DATA_DIR, num_samples=5, shuffle=True)
-# 使用ImageFolderDatasetV2读取数据集，获取5个样本
-dataset1 = ds.ImageFolderDatasetV2(DATA_DIR, num_samples=5, shuffle=True)
+def decode(image):
+ return Image.fromarray(image)
-# 创建一组数据增强算子的集合
transforms_list = [
- py_trans.Decode(), # 解码图像到PIL格式
- py_trans.Resize(size=(200,200)), # 缩放图像到[200, 200]大小
- py_trans.ToTensor() # 将PIL图像转换到Numpy
+ decode,
+ py_trans.Resize(size=(200,200)),
+ py_trans.ToTensor()
]
-compose_trans = py_trans.ComposeOp(transforms_list)
+compose_trans = Compose(transforms_list)
+dataset2 = dataset1.map(operations=compose_trans, input_columns=["image"])
-# 使用map算子将其作用到数据管道的数据集中
-dataset2 = dataset1.map(input_columns=["image"], operations=compose_trans())
-
-# 启动数据管道，输出5个样本数据
image_list, label_list = [], []
for data in dataset2.create_dict_iterator():
image_list.append(data['image'])
label_list.append(data['label'])
print("Transformed image Shape:", data['image'].shape, ", Transformed label:", data['label'])
-# 将原图与裁剪后的图可视化
num_samples = len(image_list)
for i in range(num_samples):
plt.subplot(1, len(image_list), i + 1)
- plt.imshow(image_list[i].transpose(1, 2, 0))
- plt.title(label_list[i])
+ plt.imshow(image_list[i].asnumpy().transpose(1, 2, 0))
+ plt.title(label_list[i].asnumpy())
plt.show()
```
+输出结果如下：
+
+```text
+Transformed image Shape: (3, 200, 200) , Transformed label: 4
+Transformed image Shape: (3, 200, 200) , Transformed label: 9
+Transformed image Shape: (3, 200, 200) , Transformed label: 6
+Transformed image Shape: (3, 200, 200) , Transformed label: 5
+Transformed image Shape: (3, 200, 200) , Transformed label: 7
```
-Transformed image Shape: (3, 200, 200) , Transformed label: 3
-Transformed image Shape: (3, 200, 200) , Transformed label: 0
-Transformed image Shape: (3, 200, 200) , Transformed label: 3
-Transformed image Shape: (3, 200, 200) , Transformed label: 0
-Transformed image Shape: (3, 200, 200) , Transformed label: 3
-```
+
+图片展示如下：
## 使用说明
-请勿混用c_transforms与py_transforms，因为c_transforms是在C++内维护buffer管理，py_transforms是在Python内维护buffer管理，两者混用会降低性能。
+请勿混用`c_transforms`与`py_transforms`，因为两者作用于图片的格式不同，混用会降低处理性能。
-
+
混用会引发C++与Python切换的成本，建议不要过度混用两个模块的算子，但是适量混用是可以接受的。
**推荐的使用方式：**
-- 单独使用py_transform或c_transform
+- 单独使用`py_transform`或`c_transform`
- 
+ 
-- 先使用py_transform，再使用c_transform
+- 先使用`py_transform`，再使用`c_transform`
- 
+ 
-- 先使用c_transform，再使用py_transform
+- 先使用`c_transform`，再使用`py_transform`
- 
+ 
**不推荐的使用方式：**
- 在两种transform之间频繁切换
- 
+ 
+
+## 参考文献
+
+[1] Alex Krizhevsky. [Learning Multiple Layers of Features from Tiny Images](http://www.cs.toronto.edu/~kriz/learning-features-2009-TR.pdf).
+
+[2] Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. [Gradient-based learning applied to document recognition](http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf).
diff --git a/docs/programming_guide/source_zh_cn/auto_augmentation.md b/docs/programming_guide/source_zh_cn/auto_augmentation.md
new file mode 100644
index 0000000000000000000000000000000000000000..a6359d4d96d71e043d5192f8fe78a6d870f9270b
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/auto_augmentation.md
@@ -0,0 +1,151 @@
+# 自动数据增强
+
+
+
+- [自动数据增强](#自动数据增强)
+ - [概述](#概述)
+ - [基于概率的自动数据增强](#基于概率的自动数据增强)
+ - [RandomApply](#RandomApply)
+ - [RandomChoice](#RandomChoice)
+ - [RandomSelectSubpolicy](#RandomSelectSubpolicy)
+ - [基于回调参数的自动数据增强](#基于回调参数的自动数据增强)
+
+
+
+
+
+## 概述
+
+MindSpore除了可以让用户自定义数据增强的使用，还提供了一种自动数据增强方式，可以基于特定策略自动对图像进行数据增强处理。
+
+自动数据增强主要分为基于概率的自动数据增强和基于回调参数的自动数据增强。
+
+## 基于概率的自动数据增强
+
+MindSpore提供了一系列基于概率的自动数据增强API，用户可以对各种数据增强操作进行随机选择与组合，使数据增强更加灵活。
+
+关于API的详细说明，可以参见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.dataset.transforms.html)。
+
+### RandomApply
+
+API接收一个数据增强操作列表`transforms`，以一定的概率顺序执行列表中各数据增强操作，默认概率为0.5，否则都不执行。
+
+在下面的代码示例中，以0.5的概率来顺序执行`RandomCrop`和`RandomColorAdjust`操作，否则都不执行。
+
+```python
+import mindspore.dataset.vision.c_transforms as c_vision
+from mindspore.dataset.transforms.c_transforms import RandomApply
+
+rand_apply_list = RandomApply([c_vision.RandomCrop(512), c_vision.RandomColorAdjust()])
+```
+
+### RandomChoice
+
+API接收一个数据增强操作列表`transforms`，从中随机选择一个数据增强操作执行。
+
+在下面的代码示例中，等概率地在`CenterCrop`和`RandomCrop`中选择一个操作执行。
+
+```python
+import mindspore.dataset.vision.c_transforms as c_vision
+from mindspore.dataset.transforms.c_transforms import RandomChoice
+
+rand_choice = RandomChoice([c_vision.CenterCrop(512), c_vision.RandomCrop(512)])
+```
+
+### RandomSelectSubpolicy
+
+API接收一个预置策略列表，包含一系列子策略组合，每一子策略由若干个顺序执行的数据增强操作及其执行概率组成。
+
+对各图像先等概率随机选择一种子策略，再依照子策略中的概率顺序执行各个操作。
+
+在下面的代码示例中，预置了两条子策略，子策略1中包含`RandomRotation`、`RandomVerticalFlip`和`RandomColorAdjust`三个操作，概率分别为0.5、1.0和0.8；子策略2中包含`RandomRotation`和`RandomColorAdjust`两个操作，概率分别为1.0和0.2。
+
+```python
+import mindspore.dataset.vision.c_transforms as c_vision
+from mindspore.dataset.vision.c_transforms import RandomSelectSubpolicy
+
+policy_list = [
+ [(c_vision.RandomRotation((45, 45)), 0.5), (c_vision.RandomVerticalFlip(), 1.0), (c_vision.RandomColorAdjust(), 0.8)],
+ [(c_vision.RandomRotation((90, 90)), 1.0), (c_vision.RandomColorAdjust(), 0.2)]
+ ]
+policy = RandomSelectSubpolicy(policy_list)
+```
+
+## 基于回调参数的自动数据增强
+
+MindSpore的`sync_wait`接口支持按batch或epoch粒度在训练过程中动态调整数据增强策略，用户可以设定阻塞条件触发特定的数据增强操作。
+
+`sync_wait`将阻塞整个数据处理pipeline直到`sync_update`触发用户预先定义的`callback`函数，两者需配合使用，对应说明如下：
+
+- sync_wait(condition_name, num_batch=1, callback=None)
+
+ 该API为数据集添加一个阻塞条件`condition_name`，当`sync_update`调用时执行指定的`callback`函数。
+
+- sync_update(condition_name, num_batch=None, data=None)
+
+ 该API用于释放对应`condition_name`的阻塞，并对`data`触发指定的`callback`函数。
+
+下面将演示基于回调参数的自动数据增强的用法。
+
+1. 用户预先定义`Augment`类，其中`preprocess`为自定义的数据增强函数，`update`为更新数据增强策略的回调函数。
+
+ ```python
+ import mindspore.dataset.vision.py_transforms as transforms
+ import mindspore.dataset as ds
+ import numpy as np
+
+ class Augment:
+ def __init__(self):
+ self.ep_num = 0
+ self.step_num = 0
+
+ def preprocess(self, input_):
+ return (np.array((input_ + self.step_num ** self.ep_num - 1), ))
+
+ def update(self, data):
+ self.ep_num = data['ep_num']
+ self.step_num = data['step_num']
+ ```
+
+2. 数据处理pipeline先回调自定义的增强策略更新函数`update`，然后在`map`操作中按更新后的策略来执行`preprocess`中定义的数据增强操作。
+
+ ```python
+ arr = list(range(1, 4))
+ dataset = ds.NumpySlicesDataset(arr, shuffle=False)
+ aug = Augment()
+ dataset = dataset.sync_wait(condition_name="policy", callback=aug.update)
+ dataset = dataset.map(operations=[aug.preprocess])
+ ```
+
+3. 在每个step中调用`sync_update`进行数据增强策略的更新。
+
+ ```python
+ epochs = 5
+ itr = dataset.create_tuple_iterator(num_epochs=epochs)
+ step_num = 0
+ for ep_num in range(epochs):
+ for data in itr:
+ print("epcoh: {}, step:{}, data :{}".format(ep_num, step_num, data))
+ step_num += 1
+ dataset.sync_update(condition_name="policy", data={'ep_num': ep_num, 'step_num': step_num})
+ ```
+
+ 输出结果如下：
+
+ ```text
+ epcoh: 0, step:0, data :[Tensor(shape=[], dtype=Int64, value= 1)]
+ epcoh: 0, step:1, data :[Tensor(shape=[], dtype=Int64, value= 2)]
+ epcoh: 0, step:2, data :[Tensor(shape=[], dtype=Int64, value= 3)]
+ epcoh: 1, step:3, data :[Tensor(shape=[], dtype=Int64, value= 1)]
+ epcoh: 1, step:4, data :[Tensor(shape=[], dtype=Int64, value= 5)]
+ epcoh: 1, step:5, data :[Tensor(shape=[], dtype=Int64, value= 7)]
+ epcoh: 2, step:6, data :[Tensor(shape=[], dtype=Int64, value= 6)]
+ epcoh: 2, step:7, data :[Tensor(shape=[], dtype=Int64, value= 50)]
+ epcoh: 2, step:8, data :[Tensor(shape=[], dtype=Int64, value= 66)]
+ epcoh: 3, step:9, data :[Tensor(shape=[], dtype=Int64, value= 81)]
+ epcoh: 3, step:10, data :[Tensor(shape=[], dtype=Int64, value= 1001)]
+ epcoh: 3, step:11, data :[Tensor(shape=[], dtype=Int64, value= 1333)]
+ epcoh: 4, step:12, data :[Tensor(shape=[], dtype=Int64, value= 1728)]
+ epcoh: 4, step:13, data :[Tensor(shape=[], dtype=Int64, value= 28562)]
+ epcoh: 4, step:14, data :[Tensor(shape=[], dtype=Int64, value= 38418)]
+ ```
diff --git a/api/source_zh_cn/programming_guide/auto_parallel_context.md b/docs/programming_guide/source_zh_cn/auto_parallel.md
similarity index 73%
rename from api/source_zh_cn/programming_guide/auto_parallel_context.md
rename to docs/programming_guide/source_zh_cn/auto_parallel.md
index 14ce9bdab9d86ddc8e66279f2d92167cc2ae0f48..335632b9954c80023bf1482b34fcc8fe112b5d38 100644
--- a/api/source_zh_cn/programming_guide/auto_parallel_context.md
+++ b/docs/programming_guide/source_zh_cn/auto_parallel.md
@@ -6,31 +6,34 @@
- [概述](#概述)
- [分布式并行配置](#分布式并行配置)
- [通用配置](#通用配置)
- - [device_num](#device_num)
- - [global_rank](#global_rank)
- - [gradients_mean](#gradients_mean)
- - [parallel_mode](#parallel_mode)
+ - [device_num](#device_num)
+ - [global_rank](#global_rank)
+ - [gradients_mean](#gradients_mean)
+ - [parallel_mode](#parallel_mode)
+ - [all_reduce_fusion_config](#all_reduce_fusion_config)
- [自动并行配置](#自动并行配置)
- - [gradient_fp32_sync](#gradient_fp32-sync)
- - [loss_repeated_mean](#loss_repeated_mean)
- - [auto_parallel_search_mode](#auto_parallel_search_mode)
- - [strategy_ckpt_load_file](#strategy_ckpt_load_file)
- - [strategy_ckpt_save_file](#strategy_ckpt_save_file)
- - [full_batch](#full_batch)
+ - [gradient_fp32_sync](#gradient_fp32_sync)
+ - [auto_parallel_search_mode](#auto_parallel_search_mode)
+ - [strategy_ckpt_load_file](#strategy_ckpt_load_file)
+ - [strategy_ckpt_save_file](#strategy_ckpt_save_file)
+ - [full_batch](#full_batch)
- [数据并行配置](#数据并行配置)
- - [enable_parallel_optimizer](#enable_parallel_optimizer)
+ - [enable_parallel_optimizer](#enable_parallel_optimizer)
- [混合并行配置](#混合并行配置)
- - [layerwise_parallel](#layerwise_parallel)
+ - [layerwise_parallel](#layerwise_parallel)
- [分布式通信接口](#分布式通信接口)
- [init](#init)
- - [get_rank](#get_rank)
- [get_group_size](#get_group_size)
+ - [get_rank](#get_rank)
+ - [分布式属性配置](#分布式属性配置)
+ - [cross_batch](#cross_batch)
+ - [fusion](#fusion)
- [数据并行](#数据并行)
- [自动并行](#自动并行)
-
+
## 概述
@@ -43,7 +46,7 @@ MindSpore提供了分布式并行训练的功能，它支持了包括数据并
MindSpore的分布式并行配置通过`auto_parallel_context`来进行集中管理，用户可根据自身需求和实际情况来进行个性化的配置。这些配置可分为四大类：
- 通用配置：对数据并行和自动并行均起作用的配置，如：`device_num`、`global_rank`。
-- 自动并行配置：仅在自动并行模式下起作用的配置，如：`gradient_fp32_sync`、`loss_repeated_mean`。
+- 自动并行配置：仅在自动并行模式下起作用的配置，如：`gradient_fp32_sync`。
- 数据并行配置：仅在数据并行模式下起作用的配置，如：`enable_parallel_optimizer`。
- 混合并行配置：仅在混合并行模式下起作用的配置，如：`layerwise_parallel`。
@@ -58,7 +61,7 @@ MindSpore的分布式并行配置通过`auto_parallel_context`来进行集中管
代码样例如下：
```python
-from mindspore import context
+from mindspore import context
context.set_auto_parallel_context(device_num=8)
context.get_auto_parallel_context("device_num")
@@ -71,7 +74,7 @@ context.get_auto_parallel_context("device_num")
代码样例如下：
```python
-from mindspore import context
+from mindspore import context
context.set_auto_parallel_context(global_rank=0)
context.get_auto_parallel_context("global_rank")
@@ -84,7 +87,7 @@ context.get_auto_parallel_context("global_rank")
代码样例如下：
```python
-from mindspore import context
+from mindspore import context
context.set_auto_parallel_context(gradients_mean=False)
context.get_auto_parallel_context("gradients_mean")
@@ -95,17 +98,23 @@ context.get_auto_parallel_context("gradients_mean")
`parallel_mode`表示并行模式，其值为字符串类型。用户可选择的模式有：
- `stand_alone`：单机模式。
-- `data_parallel`：数据并行模式。
-- `hybrid_parallel`：混合并行模式。
-- `semi_auto_parallel`：半自动并行模式，即用户可通过`set_strategy`方法给算子配置切分策略，若不配置策略，则默认是数据并行策略。
-- `auto_parallel`：自动并行模式，即框架会自动建立代价模型，为用户选择最优的切分策略。
+- `data_parallel`：数据并行模式。
+- `hybrid_parallel`：混合并行模式。
+- `semi_auto_parallel`：半自动并行模式，即用户可通过`shard`方法给算子配置切分策略，若不配置策略，则默认是数据并行策略。
+- `auto_parallel`：自动并行模式，即框架会自动建立代价模型，为用户选择最优的切分策略。
+
+其中`auto_parallel`和`data_parallel`在MindSpore教程中有完整样例：
+
+
+
## 概述
+
Callback回调函数在MindSpore中被实现为一个类，Callback机制类似于一种监控模式，可以帮助用户观察网络训练过程中各种参数的变化情况和网络内部的状态，还可以根据用户的指定，在达到特定条件后执行相应的操作，在训练过程中，Callback列表会按照定义的顺序执行Callback函数。Callback机制让用户可以及时有效地掌握网络模型的训练状态，并根据需要随时作出调整，可以极大地提升用户的开发效率。
-在MindSpore中，Callback机制一般用在网络训练过程`model.train`中，用户可以通过配置不同的内置回调函数传入不同的参数，从而实现各种功能。例如，可以通过`LossMonitor`监控每一个epoch的loss变化情况，通过checkpoint保存网络参数和模型进行再训练或推理，通过`TimeMonitor`监控每一个epoch，每一个step的训练时间，以及提前终止训练，动态调整参数等。
+在MindSpore中，Callback机制一般用在网络训练过程`model.train`中，用户可以通过配置不同的内置回调函数传入不同的参数，从而实现各种功能。例如，可以通过`LossMonitor`监控每一个epoch的loss变化情况，通过`ModelCheckpoint`保存网络参数和模型进行再训练或推理，通过`TimeMonitor`监控每一个epoch，每一个step的训练时间，以及提前终止训练，动态调整参数等。
## MindSpore内置回调函数
- ModelCheckpoint
- 与模型训练过程相结合，保存训练后的模型和网络参数，方便进行再推理或再训练。
-
-- CheckpointConfig
-
- 一般与`ModelCheckpoint`配合使用，可自定义配置checkpoint的保存策略。
+ 与模型训练过程相结合，保存训练后的模型和网络参数，方便进行再推理或再训练。`ModelCheckpoint`一般与`CheckpointConfig`配合使用，`CheckpointConfig`是一个参数配置类，可自定义配置checkpoint的保存策略。
- 详细内容，请参考[Checkpoint官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/use/saving_and_loading_model_parameters.html)。
+ 详细内容，请参考[Checkpoint官网教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/use/save_model.html)。
- SummaryCollector
帮助收集一些常见信息，如loss、learning rate、计算图、参数权重等，方便用户将训练过程可视化和查看信息，并且可以允许summary操作从summary文件中收集数据。
- 详细内容，请参考[Summary官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/summary_record.html)。
+ 详细内容，请参考[Summary官网教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/summary_record.html)。
- LossMonitor
监控训练过程中的loss变化情况，当loss为NAN或INF时，提前终止训练。可以在日志中输出loss，方便用户查看。
- 详细内容，请参考[LossMonitor官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/second_order_optimizer_for_resnet50_application.html#id11)。
+ 详细内容，请参考[LossMonitor官网教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/custom_debugging_info.html#mindsporecallback)。
- TimeMonitor
-
- 监控训练过程中每个epoch，每个step的运行时间。
- 详细内容，请参考[TimeMonitor官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/second_order_optimizer_for_resnet50_application.html#id11)。
+ 监控训练过程中每个epoch，每个step的运行时间。
## MindSpore自定义回调函数
+
MindSpore不但有功能强大的内置回调函数，还可以支持用户自定义回调函数。当用户有自己的特殊需求时，可以基于Callback基类，自定义满足用户自身需求的回调函数。Callback可以把训练过程中的重要信息记录下来，通过一个字典类型变量cb_params传递给Callback对象， 用户可以在各个自定义的Callback中获取到相关属性，执行自定义操作。
以下面两个场景为例，介绍自定义Callback回调函数的功能：
@@ -54,6 +51,6 @@ MindSpore不但有功能强大的内置回调函数，还可以支持用户自
2. 实现保存训练过程中精度最高的checkpoint文件，用户可以自定义在每一轮迭代后都保存当前精度最高的模型。
-详细内容，请参考[自定义Callback官网教程](https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/customized_debugging_information.html#id3)。
+详细内容，请参考[自定义Callback官网教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/custom_debugging_info.html#id3)。
-根据教程，用户可以很容易实现具有其他功能的自定义回调函数，如实现在每一轮训练结束后都输出相应的详细训练信息，包括训练进度、训练轮次、训练名称、loss值等；如实现在loss或模型精度达到一定值后停止训练，用户可以设定loss或模型精度的阈值，当loss或模型精度达到该阈值后就提前终止训练等。
\ No newline at end of file
+根据教程，用户可以很容易实现具有其他功能的自定义回调函数，如实现在每一轮训练结束后都输出相应的详细训练信息，包括训练进度、训练轮次、训练名称、loss值等；如实现在loss或模型精度达到一定值后停止训练，用户可以设定loss或模型精度的阈值，当loss或模型精度达到该阈值后就提前终止训练等。
diff --git a/docs/programming_guide/source_zh_cn/cell.md b/docs/programming_guide/source_zh_cn/cell.md
new file mode 100644
index 0000000000000000000000000000000000000000..3b778732c45dfea1166ba67aa9ce55bdc2204d58
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/cell.md
@@ -0,0 +1,380 @@
+# Cell构建及其子类
+
+
+
+- [Cell构建及其子类](#cell构建及其子类)
+ - [概述](#概述)
+ - [关键成员函数](#关键成员函数)
+ - [construct方法](#construct方法)
+ - [parameters_dict](#parameters_dict)
+ - [cells_and_names](#cells_and_names)
+ - [set_grad](#set_grad)
+ - [nn模块与ops模块的关系](#nn模块与ops模块的关系)
+ - [模型层](#模型层)
+ - [内置模型层](#内置模型层)
+ - [应用实例](#应用实例)
+ - [损失函数](#损失函数)
+ - [内置损失函数](#内置损失函数)
+ - [应用实例](#应用实例-1)
+ - [优化算法](#优化算法)
+ - [构建自定义网络](#构建自定义网络)
+
+
+
+
+
+## 概述
+
+MindSpore的`Cell`类是构建所有网络的基类，也是网络的基本单元。当用户需要自定义网络时，需要继承`Cell`类，并重写`__init__`方法和`contruct`方法。
+
+损失函数、优化器和模型层等本质上也属于网络结构，也需要继承`Cell`类才能实现功能，同样用户也可以根据业务需求自定义这部分内容。
+
+本节内容首先将会介绍`Cell`类的关键成员函数，然后介绍基于`Cell`实现的MindSpore内置损失函数、优化器和模型层及使用方法，最后通过实例介绍如何利用`Cell`类构建自定义网络。
+
+## 关键成员函数
+
+### construct方法
+
+`Cell`类重写了`__call__`方法，在`Cell`类的实例被调用时，会执行`construct`方法。网络结构在`construct`方法里面定义。
+
+下面的样例中，我们构建了一个简单的网络实现卷积计算功能。构成网络的算子在`__init__`中定义，在`construct`方法里面使用，用例的网络结构为`Conv2d`->`BiasAdd`。
+
+在`construct`方法中，`x`为输入数据，`output`是经过网络结构计算后得到的计算结果。
+
+```python
+import mindspore.nn as nn
+import mindspore.ops as ops
+from mindspore.common.parameter import Parameter
+from mindspore.common.initializer import initializer
+
+class Net(nn.Cell):
+ def __init__(self, in_channels=10, out_channels=20, kernel_size=3):
+ super(Net, self).__init__()
+ self.conv2d = ops.Conv2D(out_channels, kernel_size)
+ self.bias_add = ops.BiasAdd()
+ self.weight = Parameter(
+ initializer('normal', [out_channels, in_channels, kernel_size, kernel_size]),
+ name='conv.weight')
+
+ def construct(self, x):
+ output = self.conv2d(x, self.weight)
+ output = self.bias_add(output, self.bias)
+ return output
+```
+
+### parameters_dict
+
+`parameters_dict`方法识别出网络结构中所有的参数，返回一个以key为参数名，value为参数值的`OrderedDict`。
+
+`Cell`类中返回参数的方法还有许多，例如`get_parameters`、`trainable_params`等，具体使用方法可以参见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.nn.html#mindspore.nn.Cell)。
+
+代码样例如下：
+
+```python
+net = Net()
+result = net.parameters_dict()
+print(result.keys())
+print(result['conv.weight'])
+```
+
+样例中的`Net`采用上文构造网络的用例，打印了网络中所有参数的名字和`conv.weight`参数的结果。
+
+输出如下：
+
+```text
+odict_keys(['conv.weight'])
+Parameter (name=conv.weight, value=[[[[-3.95042636e-03 1.08830128e-02 -6.51786150e-03]
+ [ 8.66129529e-03 7.36288540e-03 -4.32638079e-03]
+ [-1.47628486e-02 8.24100431e-03 -2.71035335e-03]]
+ ......
+ [ 1.58852488e-02 -1.03505487e-02 1.72988791e-02]]]])
+```
+
+### cells_and_names
+
+`cells_and_names`方法是一个迭代器，返回网络中每个`Cell`的名字和它的内容本身。
+
+用例简单实现了获取与打印每个`Cell`名字的功能，其中根据网络结构可知，存在1个`Cell`为`nn.Conv2d`。
+
+其中`nn.Conv2d`是MindSpore以`Cell`为基类封装好的一个卷积层，其具体内容将在“模型层”中进行介绍。
+
+代码样例如下：
+
+```python
+import mindspore.nn as nn
+
+class Net1(nn.Cell):
+ def __init__(self):
+ super(Net1, self).__init__()
+ self.conv = nn.Conv2d(3, 64, 3, has_bias=False, weight_init='normal')
+
+ def construct(self, x):
+ out = self.conv(x)
+ return out
+
+net = Net1()
+names = []
+for m in net.cells_and_names():
+ print(m)
+ names.append(m[0]) if m[0] else None
+print('-------names-------')
+print(names)
+```
+
+输出如下：
+
+```text
+('', Net1<
+ (conv): Conv2d
+
+## 概述
+
+初始化网络之前要配置context参数，用于控制程序执行的策略。比如选择执行模式、选择执行后端、配置分布式相关参数等。按照context参数设置实现的不同功能，可以将其分为执行模式管理、硬件管理、分布式管理和维测管理等。
+
+## 执行模式管理
+
+MindSpore支持PyNative和Graph这两种运行模式：
+
+- `PYNATIVE_MODE`：动态图模式，将神经网络中的各个算子逐一下发执行，方便用户编写和调试神经网络模型。
+
+- `GRAPH_MODE`：静态图模式或者图模式，将神经网络模型编译成一整张图，然后下发执行。该模式利用图优化等技术提高运行性能，同时有助于规模部署和跨平台运行。
+
+### 模式选择
+
+通过设置可以控制程序运行的模式，默认情况下，MindSpore处于PyNative模式。
+
+代码样例如下：
+
+```python
+from mindspore import context
+context.set_context(mode=context.GRAPH_MODE)
+```
+
+### 模式切换
+
+实现两种模式之间的切换。
+
+MindSpore处于PYNATIVE模式时，可以通过`context.set_context(mode=context.GRAPH_MODE)`切换为Graph模式；同样地，MindSpore处于Graph模式时，可以通过 `context.set_context(mode=context.PYNATIVE_MODE)`切换为PyNative模式。
+
+代码样例如下：
+
+```python
+import numpy as np
+import mindspore.nn as nn
+from mindspore import context, Tensor
+
+context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
+
+conv = nn.Conv2d(3, 4, 3, bias_init='zeros')
+input_data = Tensor(np.ones([1, 3, 5, 5]).astype(np.float32))
+conv(input_data)
+context.set_context(mode=context.PYNATIVE_MODE)
+conv(input_data)
+```
+
+上面的例子先将运行模式设置为`GRAPH_MODE`模式，然后将模式切换为`PYNATIVE_MODE`模式，实现了模式的切换。
+
+## 硬件管理
+
+硬件管理部分主要包括`device_target`和`device_id`两个参数。
+
+- `device_target`： 用于设置目标设备，支持Ascend、GPU和CPU，可以根据实际环境情况设置。
+
+- `device_id`： 表示卡物理序号，即卡所在机器中的实际序号。如果目标设备为Ascend，且规格为N*Ascend（其中N>1，如8*Ascend），在非分布式模式执行的情况下，为了避免设备的使用冲突，可以通过设置`device_id`决定程序执行的device编号，该编号范围为：0 ~ 服务器总设备数量-1，服务器总设备数量不能超过4096，默认为设备0。
+
+> 在GPU和CPU上，设置`device_id`参数无效。
+
+代码样例如下：
+
+```python
+from mindspore import context
+context.set_context(device_target="Ascend", device_id=6)
+```
+
+## 分布式管理
+
+context中有专门用于配置并行训练参数的接口：context.set_auto_parallel_context，该接口必须在初始化网络之前调用。
+
+- `parallel_mode`：分布式并行模式，默认为单机模式`ParallelMode.STAND_ALONE`。可选数据并行`ParallelMode.DATA_PARALLEL`及自动并行`ParallelMode.AUTO_PARALLEL`。
+
+- `gradients_mean`：反向计算时，框架内部会将数据并行参数分散在多台机器的梯度值进行收集，得到全局梯度值后再传入优化器中更新。默认值为`False`，设置为True对应`allreduce_mean`操作，False对应`allreduce_sum`操作。
+
+- `enable_parallel_optimizer`：开发中特性。打开优化器模型并行开关，通过拆分权重到各卡分别进行更新再同步的方式以提升性能。该参数目前只在数据并行模式和参数量大于机器数时有效，支持`Lamb`和`Adam`优化器。
+
+> `device_num`和`global_rank`建议采用默认值，框架内会调用HCCL接口获取。
+
+代码样例如下：
+
+```python
+from mindspore import context
+from mindspore.context import ParallelMode
+context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL, gradients_mean=True)
+```
+
+> 分布式并行训练详细介绍可以查看[分布式并行训练](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/distributed_training_tutorials.html)。
+
+## 维测管理
+
+为了方便维护和定位问题，context提供了大量维测相关的参数配置，如采集profiling数据、异步数据dump功能和print算子落盘等。
+
+### 采集profiling数据
+
+系统支持在训练过程中采集profiling数据，然后通过profiling工具进行性能分析。当前支持采集的profiling数据包括：
+
+- `enable_profiling`：是否开启profiling功能。设置为True，表示开启profiling功能，从enable_options读取profiling的采集选项；设置为False，表示关闭profiling功能，仅采集training_trace。
+
+- `enable_options`：profiling采集选项，取值如下，支持采集多项数据。training_trace：采集迭代轨迹数据，即训练任务及AI软件栈的软件信息，实现对训练任务的性能分析，重点关注数据增强、前后向计算、梯度聚合更新等相关数据；task_trace：采集任务轨迹数据，即昇腾910处理器HWTS/AICore的硬件信息，分析任务开始、结束等信息；op_trace：采集单算子性能数据。格式：['op_trace','task_trace','training_trace']
+
+代码样例如下：
+
+```python
+from mindspore import context
+context.set_context(enable_profiling=True, profiling_options="training_trace")
+```
+
+### 异步数据dump功能
+
+在Ascend环境上执行训练，当训练结果和预期有偏差时，可以通过异步数据dump功能保存算子的输入输出进行调试。
+
+代码样例如下：
+
+```python
+from mindspore import context
+context.set_context(save_graphs=True)
+```
+
+> 详细的调试方法可以查看[异步数据Dump功能介绍](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/custom_debugging_info.html#dump)。
+
+### print算子落盘
+
+默认情况下，MindSpore的自研print算子可以将用户输入的Tensor或字符串信息打印出来，支持多字符串输入，多Tensor输入和字符串与Tensor的混合输入，输入参数以逗号隔开。
+
+> Print打印功能可以查看[Print算子功能介绍](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/custom_debugging_info.html#print)。
+
+- `print_file_path`：可以将print算子数据保存到文件，同时关闭屏幕打印功能。如果保存的文件已经存在，则会给文件添加时间戳后缀。数据保存到文件可以解决数据量较大时屏幕打印数据丢失的问题。
+
+代码样例如下：
+
+```python
+from mindspore import context
+context.set_context(print_file_path="print.pb")
+```
+
+> context接口详细介绍可以查看[mindspore.context](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.context.html)。
diff --git a/docs/programming_guide/source_zh_cn/customized.rst b/docs/programming_guide/source_zh_cn/customized.rst
new file mode 100644
index 0000000000000000000000000000000000000000..ea01f97396104cd56d8b4c2e071bcf4680eae526
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/customized.rst
@@ -0,0 +1,9 @@
+自定义算子
+===========
+
+.. toctree::
+ :maxdepth: 1
+
+ 自定义算子（Ascend）
+
+## 概述
+
+用户可以将非标准的数据集和常用的数据集转换为MindSpore数据格式，即MindRecord，从而方便地加载到MindSpore中进行训练。同时，MindSpore在部分场景做了性能优化，使用MindRecord可以获得更好的性能。
+
+## 非标准数据集转换MindRecord
+
+下面主要介绍如何将CV类数据和NLP类数据转换为MindRecord，并通过`MindDataset`实现MindRecord文件的读取。
+
+### 转换CV类数据集
+
+本示例主要介绍用户如何将自己的CV类数据集转换成MindRecord，并使用`MindDataset`读取。
+
+本示例首先创建一个包含100条记录的MindRecord文件，其样本包含`file_name`（字符串）、
+`label`（整形）、 `data`（二进制）三个字段，然后使用`MindDataset`读取该MindRecord文件。
+
+```python
+from io import BytesIO
+import os
+import mindspore.dataset as ds
+from mindspore.mindrecord import FileWriter
+import mindspore.dataset.vision.c_transforms as vision
+from PIL import Image
+
+mindrecord_filename = "test.mindrecord"
+
+if os.path.exists(mindrecord_filename):
+ os.remove(mindrecord_filename)
+ os.remove(mindrecord_filename + ".db")
+
+writer = FileWriter(file_name=mindrecord_filename, shard_num=1)
+
+cv_schema = {"file_name": {"type": "string"}, "label": {"type": "int32"}, "data": {"type": "bytes"}}
+writer.add_schema(cv_schema, "it is a cv dataset")
+
+writer.add_index(["file_name", "label"])
+
+data = []
+for i in range(100):
+ i += 1
+
+ sample = {}
+ white_io = BytesIO()
+ Image.new('RGB', (i*10, i*10), (255, 255, 255)).save(white_io, 'JPEG')
+ image_bytes = white_io.getvalue()
+ sample['file_name'] = str(i) + ".jpg"
+ sample['label'] = i
+ sample['data'] = white_io.getvalue()
+
+ data.append(sample)
+ if i % 10 == 0:
+ writer.write_raw_data(data)
+ data = []
+
+if data:
+ writer.write_raw_data(data)
+
+writer.commit()
+
+data_set = ds.MindDataset(dataset_file=mindrecord_filename)
+decode_op = vision.Decode()
+data_set = data_set.map(operations=decode_op, input_columns=["data"], num_parallel_workers=2)
+count = 0
+for item in data_set.create_dict_iterator(output_numpy=True):
+ print("sample: {}".format(item))
+ count += 1
+print("Got {} samples".format(count))
+```
+
+### 转换NLP类数据集
+
+本示例主要介绍用户如何将自己的NLP类数据集转换成MindRecord，并使用`MindDataset`读取。为了方便展示，此处略去了将文本转换成字典序的预处理过程。
+
+本示例首先创建一个包含100条记录的MindRecord文件，其样本包含八个字段，均为整形数组，然后使用`MindDataset`读取该MindRecord文件。
+
+```python
+import os
+import numpy as np
+import mindspore.dataset as ds
+from mindspore.mindrecord import FileWriter
+
+mindrecord_filename = "test.mindrecord"
+
+if os.path.exists(mindrecord_filename):
+ os.remove(mindrecord_filename)
+ os.remove(mindrecord_filename + ".db")
+
+writer = FileWriter(file_name=mindrecord_filename, shard_num=1)
+
+nlp_schema = {"source_sos_ids": {"type": "int64", "shape": [-1]},
+ "source_sos_mask": {"type": "int64", "shape": [-1]},
+ "source_eos_ids": {"type": "int64", "shape": [-1]},
+ "source_eos_mask": {"type": "int64", "shape": [-1]},
+ "target_sos_ids": {"type": "int64", "shape": [-1]},
+ "target_sos_mask": {"type": "int64", "shape": [-1]},
+ "target_eos_ids": {"type": "int64", "shape": [-1]},
+ "target_eos_mask": {"type": "int64", "shape": [-1]}}
+writer.add_schema(nlp_schema, "it is a preprocessed nlp dataset")
+
+data = []
+for i in range(100):
+ i += 1
+
+ sample = {"source_sos_ids": np.array([i, i+1, i+2, i+3, i+4], dtype=np.int64),
+ "source_sos_mask": np.array([i*1, i*2, i*3, i*4, i*5, i*6, i*7], dtype=np.int64),
+ "source_eos_ids": np.array([i+5, i+6, i+7, i+8, i+9, i+10], dtype=np.int64),
+ "source_eos_mask": np.array([19, 20, 21, 22, 23, 24, 25, 26, 27], dtype=np.int64),
+ "target_sos_ids": np.array([28, 29, 30, 31, 32], dtype=np.int64),
+ "target_sos_mask": np.array([33, 34, 35, 36, 37, 38], dtype=np.int64),
+ "target_eos_ids": np.array([39, 40, 41, 42, 43, 44, 45, 46, 47], dtype=np.int64),
+ "target_eos_mask": np.array([48, 49, 50, 51], dtype=np.int64)}
+
+ data.append(sample)
+ if i % 10 == 0:
+ writer.write_raw_data(data)
+ data = []
+
+if data:
+ writer.write_raw_data(data)
+
+writer.commit()
+
+data_set = ds.MindDataset(dataset_file=mindrecord_filename)
+count = 0
+for item in data_set.create_dict_iterator():
+ print("sample: {}".format(item))
+ count += 1
+print("Got {} samples".format(count))
+```
+
+## 常用数据集转换MindRecord
+
+MindSpore提供转换常用数据集的工具类，能够将常用的数据集转换为MindRecord。常用数据集及其对应的工具类列表如下。
+
+| 数据集 | 格式转换工具类 |
+| -------- | ------------ |
+| CIFAR-10 | Cifar10ToMR |
+| CIFAR-100 | Cifar100ToMR |
+| ImageNet | ImageNetToMR |
+| MNIST | MnistToMR |
+| TFRecord | TFRecordToMR |
+| CSV File | CsvToMR |
+
+更多数据集转换的详细说明可参见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.mindrecord.html)。
+
+### 转换CIFAR-10数据集
+
+用户可以通过`Cifar10ToMR`类，将CIFAR-10原始数据转换为MindRecord，并使用`MindDataset`读取。
+
+1. 下载[CIFAR-10数据集](https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz)并解压，其目录结构如下所示。
+
+ ```text
+ └─cifar-10-batches-py
+ ├─batches.meta
+ ├─data_batch_1
+ ├─data_batch_2
+ ├─data_batch_3
+ ├─data_batch_4
+ ├─data_batch_5
+ ├─readme.html
+ └─test_batch
+ ```
+
+2. 导入数据集转换工具类`Cifar10ToMR`。
+
+ ```python
+ from mindspore.mindrecord import Cifar10ToMR
+ ```
+
+3. 创建`Cifar10ToMR`对象，调用`transform`接口，将CIFAR-10数据集转换为MindRecord。
+
+ ```python
+ CIFAR10_DIR = "./cifar-10-batches-py"
+ MINDRECORD_FILE = "./cifar10.mindrecord"
+ cifar10_transformer = Cifar10ToMR(CIFAR10_DIR, MINDRECORD_FILE)
+ cifar10_transformer.transform(['label'])
+ ```
+
+ **参数说明：**
+ - `CIFAR10_DIR`：CIFAR-10数据集的文件夹路径。
+ - `MINDRECORD_FILE`：输出的MindRecord文件路径。
+
+4. 通过`MindDataset`读取MindRecord。
+
+ ```python
+ import mindspore.dataset as ds
+ import mindspore.dataset.vision.c_transforms as vision
+
+ data_set = ds.MindDataset(dataset_file=MINDRECORD_FILE)
+ decode_op = vision.Decode()
+ data_set = data_set.map(operations=decode_op, input_columns=["data"], num_parallel_workers=2)
+ count = 0
+ for item in data_set.create_dict_iterator(output_numpy=True):
+ count += 1
+ print("Got {} samples".format(count))
+ ```
+
+### 转换ImageNet数据集
+
+用户可以通过`ImageNetToMR`类，将ImageNet原始数据（图片、标注）转换为MindRecord，并使用`MindDataset`读取。
+
+1. 下载[ImageNet数据集](http://image-net.org/download)，将所有图片存放在`images/`文件夹，用一个映射文件`labels_map.txt`记录图片和标签的对应关系。映射文件包含2列，分别为各类别图片目录和标签ID，用空格隔开，映射文件示例如下：
+
+ ```text
+ n01440760 0
+ n01443537 1
+ n01484850 2
+ n01491361 3
+ n01494475 4
+ n01496331 5
+ ```
+
+ 文件目录结构如下所示：
+
+ ```text
+ ├─ labels_map.txt
+ └─ images
+ └─ ......
+ ```
+
+2. 导入数据集转换工具类`ImageNetToMR`。
+
+ ```python
+ from mindspore.mindrecord import ImageNetToMR
+ ```
+
+3. 创建`ImageNetToMR`对象，调用`transform`接口，将数据集转换为MindRecord。
+
+ ```python
+ IMAGENET_MAP_FILE = "./labels_map.txt"
+ IMAGENET_IMAGE_DIR = "./images/"
+ MINDRECORD_FILE = "./imagenet.mindrecord"
+ PARTITION_NUMBER = 8
+ imagenet_transformer = ImageNetToMR(IMAGENET_MAP_FILE, IMAGENET_IMAGE_DIR, MINDRECORD_FILE, PARTITION_NUMBER)
+ imagenet_transformer.transform()
+ ```
+
+ **参数说明：**
+ - `IMAGENET_MAP_FILE`：ImageNet数据集标签映射文件的路径。
+ - `IMAGENET_IMAGE_DIR`：包含ImageNet所有图片的文件夹路径。
+ - `MINDRECORD_FILE`：输出的MindRecord文件路径。
+
+4. 通过`MindDataset`读取MindRecord。
+
+ ```python
+ import mindspore.dataset as ds
+ import mindspore.dataset.vision.c_transforms as vision
+
+ data_set = ds.MindDataset(dataset_file=MINDRECORD_FILE + "0")
+ decode_op = vision.Decode()
+ data_set = data_set.map(operations=decode_op, input_columns=["data"], num_parallel_workers=2)
+ count = 0
+ for item in data_set.create_dict_iterator(output_numpy=True):
+ print("sample: {}".format(item))
+ count += 1
+ print("Got {} samples".format(count))
+ ```
+
+### 转换CSV数据集
+
+本示例首先创建一个包含5条记录的CSV文件，然后通过`CsvToMR`工具类将CSV文件转换为MindRecord，并最终通过`MindDataset`将其读取出来。
+
+```python
+import csv
+import os
+import mindspore.dataset as ds
+from mindspore.mindrecord import CsvToMR
+
+CSV_FILE_NAME = "test.csv"
+MINDRECORD_FILE_NAME = "test.mindrecord"
+PARTITION_NUM = 1
+
+def generate_csv():
+ headers = ["id", "name", "math", "english"]
+ rows = [(1, "Lily", 78.5, 90),
+ (2, "Lucy", 99, 85.2),
+ (3, "Mike", 65, 71),
+ (4, "Tom", 95, 99),
+ (5, "Jeff", 85, 78.5)]
+ with open(CSV_FILE_NAME, 'w', encoding='utf-8') as f:
+ writer = csv.writer(f)
+ writer.writerow(headers)
+ writer.writerows(rows)
+
+generate_csv()
+
+if os.path.exists(MINDRECORD_FILE_NAME):
+ os.remove(MINDRECORD_FILE_NAME)
+ os.remove(MINDRECORD_FILE_NAME + ".db")
+
+csv_transformer = CsvToMR(CSV_FILE_NAME, MINDRECORD_FILE_NAME, partition_number=PARTITION_NUM)
+
+csv_transformer.transform()
+
+assert os.path.exists(MINDRECORD_FILE_NAME)
+assert os.path.exists(MINDRECORD_FILE_NAME + ".db")
+
+data_set = ds.MindDataset(dataset_file=MINDRECORD_FILE_NAME)
+count = 0
+for item in data_set.create_dict_iterator(output_numpy=True):
+ print("sample: {}".format(item))
+ count += 1
+print("Got {} samples".format(count))
+```
+
+### 转换TFRecord数据集
+
+> 目前只支持TensorFlow 2.1.0及以上版本。
+
+本示例首先通过TensorFlow创建一个TFRecord文件，然后通过`TFRecordToMR`工具类将TFRecord文件转换为MindRecord，最后通过`MindDataset`将其读取出来，并使用`Decode`算子对`image_bytes`字段进行解码。
+
+```python
+import collections
+from io import BytesIO
+import os
+import mindspore.dataset as ds
+from mindspore.mindrecord import TFRecordToMR
+import mindspore.dataset.vision.c_transforms as vision
+from PIL import Image
+import tensorflow as tf
+
+TFRECORD_FILE_NAME = "test.tfrecord"
+MINDRECORD_FILE_NAME = "test.mindrecord"
+PARTITION_NUM = 1
+
+def generate_tfrecord():
+ def create_int_feature(values):
+ if isinstance(values, list):
+ feature = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
+ else:
+ feature = tf.train.Feature(int64_list=tf.train.Int64List(value=[values]))
+ return feature
+
+ def create_float_feature(values):
+ if isinstance(values, list):
+ feature = tf.train.Feature(float_list=tf.train.FloatList(value=list(values)))
+ else:
+ feature = tf.train.Feature(float_list=tf.train.FloatList(value=[values]))
+ return feature
+
+ def create_bytes_feature(values):
+ if isinstance(values, bytes):
+ white_io = BytesIO()
+ Image.new('RGB', (10, 10), (255, 255, 255)).save(white_io, 'JPEG')
+ image_bytes = white_io.getvalue()
+ feature = tf.train.Feature(bytes_list=tf.train.BytesList(value=[image_bytes]))
+ else:
+ feature = tf.train.Feature(bytes_list=tf.train.BytesList(value=[bytes(values, encoding='utf-8')]))
+ return feature
+
+ writer = tf.io.TFRecordWriter(TFRECORD_FILE_NAME)
+
+ example_count = 0
+ for i in range(10):
+ file_name = "000" + str(i) + ".jpg"
+ image_bytes = bytes(str("aaaabbbbcccc" + str(i)), encoding="utf-8")
+ int64_scalar = i
+ float_scalar = float(i)
+ int64_list = [i, i+1, i+2, i+3, i+4, i+1234567890]
+ float_list = [float(i), float(i+1), float(i+2.8), float(i+3.2),
+ float(i+4.4), float(i+123456.9), float(i+98765432.1)]
+
+ features = collections.OrderedDict()
+ features["file_name"] = create_bytes_feature(file_name)
+ features["image_bytes"] = create_bytes_feature(image_bytes)
+ features["int64_scalar"] = create_int_feature(int64_scalar)
+ features["float_scalar"] = create_float_feature(float_scalar)
+ features["int64_list"] = create_int_feature(int64_list)
+ features["float_list"] = create_float_feature(float_list)
+
+ tf_example = tf.train.Example(features=tf.train.Features(feature=features))
+ writer.write(tf_example.SerializeToString())
+ example_count += 1
+ writer.close()
+ print("Write {} rows in tfrecord.".format(example_count))
+
+generate_tfrecord()
+
+feature_dict = {"file_name": tf.io.FixedLenFeature([], tf.string),
+ "image_bytes": tf.io.FixedLenFeature([], tf.string),
+ "int64_scalar": tf.io.FixedLenFeature([], tf.int64),
+ "float_scalar": tf.io.FixedLenFeature([], tf.float32),
+ "int64_list": tf.io.FixedLenFeature([6], tf.int64),
+ "float_list": tf.io.FixedLenFeature([7], tf.float32),
+ }
+
+if os.path.exists(MINDRECORD_FILE_NAME):
+ os.remove(MINDRECORD_FILE_NAME)
+ os.remove(MINDRECORD_FILE_NAME + ".db")
+
+tfrecord_transformer = TFRecordToMR(TFRECORD_FILE_NAME, MINDRECORD_FILE_NAME, feature_dict, ["image_bytes"])
+tfrecord_transformer.transform()
+
+assert os.path.exists(MINDRECORD_FILE_NAME)
+assert os.path.exists(MINDRECORD_FILE_NAME + ".db")
+
+data_set = ds.MindDataset(dataset_file=MINDRECORD_FILE_NAME)
+decode_op = vision.Decode()
+data_set = data_set.map(operations=decode_op, input_columns=["image_bytes"], num_parallel_workers=2)
+count = 0
+for item in data_set.create_dict_iterator(output_numpy=True):
+ print("sample: {}".format(item))
+ count += 1
+print("Got {} samples".format(count))
+```
diff --git a/api/source_zh_cn/programming_guide/dataset_loading.md b/docs/programming_guide/source_zh_cn/dataset_loading.md
similarity index 54%
rename from api/source_zh_cn/programming_guide/dataset_loading.md
rename to docs/programming_guide/source_zh_cn/dataset_loading.md
index e3695494d5c24c92daa030459d8fe16f72931d7c..df71e5b17dffde19b3e682f132b900cb2a6b052a 100644
--- a/api/source_zh_cn/programming_guide/dataset_loading.md
+++ b/docs/programming_guide/source_zh_cn/dataset_loading.md
@@ -4,17 +4,15 @@
- [数据集加载](#数据集加载)
- [概述](#概述)
- - [经典数据集加载](#经典数据集加载)
- - [MNIST数据集](#mnist数据集)
- - [CIFAR10/100数据集](#cifar10100数据集)
+ - [常用数据集加载](#常用数据集加载)
+ - [CIFAR-10/100数据集](#cifar-10100数据集)
- [VOC数据集](#voc数据集)
- [COCO数据集](#coco数据集)
- [特定格式数据集加载](#特定格式数据集加载)
- [MindRecord数据格式](#mindrecord数据格式)
- [Manifest数据格式](#manifest数据格式)
- [TFRecord数据格式](#tfrecord数据格式)
- - [Numpy数据格式](#numpy数据格式)
- - [text数据格式](#text数据格式)
+ - [NumPy数据格式](#numpy数据格式)
- [CSV数据格式](#csv数据格式)
- [自定义数据集加载](#自定义数据集加载)
- [构造数据集生成函数](#构造数据集生成函数)
@@ -23,19 +21,19 @@
-
+
## 概述
-MindSpore支持加载图像领域常用的经典数据集，用户可以直接使用`mindspore.dataset`中对应的类实现数据集的加载。目前支持的经典数据集及对应的数据集类如下表所示。
+MindSpore支持加载图像领域常用的数据集，用户可以直接使用`mindspore.dataset`中对应的类实现数据集的加载。目前支持的常用数据集及对应的数据集类如下表所示。
| 图像数据集 | 数据集类 | 数据集简介 |
| ---- | ---- | ---- |
| MNIST | MnistDataset | MNIST是一个大型手写数字图像数据集，拥有60,000张训练图像和10,000张测试图像，常用于训练各种图像处理系统。 |
| CIFAR-10 | Cifar10Dataset | CIFAR-10是一个微小图像数据集，包含10种类别下的60,000张32x32大小彩色图像，平均每种类别6,000张，其中5,000张为训练集，1,000张为测试集。 |
| CIFAR-100 | Cifar100Dataset | CIFAR-100与CIFAR-10类似，但拥有100种类别，平均每种类别600张，其中500张为训练集，100张为测试集。 |
-|CelebA | CelebADataset | CelebA是一个大型人脸图像数据集，包含超过200,000张名人人脸图像，每张图像拥有40个特征标记。 |
-| PASCAL-VOC | VOCDataset | PASCAL-VOC是一个经典图像数据集，被广泛用于目标检测、图像分割等计算机视觉领域。 |
+| CelebA | CelebADataset | CelebA是一个大型人脸图像数据集，包含超过200,000张名人人脸图像，每张图像拥有40个特征标记。 |
+| PASCAL-VOC | VOCDataset | PASCAL-VOC是一个常用图像数据集，被广泛用于目标检测、图像分割等计算机视觉领域。 |
| COCO | CocoDataset | COCO是一个大型目标检测、图像分割、姿态估计数据集。 |
| CLUE | CLUEDataset | CLUE是一个大型中文语义理解数据集。 |
@@ -45,104 +43,101 @@ MindSpore还支持加载多种数据存储格式下的数据集，用户可以
| ---- | ---- | ---- |
| MindRecord | MindDataset | MindRecord是MindSpore的自研数据格式，具有读写高效、易于分布式处理等优势。 |
| Manifest | ManifestDataset | Manifest是华为ModelArts支持的一种数据格式，描述了原始文件和标注信息，可用于标注、训练、推理场景。 |
-| TFRecord | TFRecordDataset | TFRecord是Tensorflow定义的一种二进制数据文件格式。 |
-| Numpy | NumpySlicesDataset | Numpy数据源指的是已经读入内存中的Numpy arrays格式数据集。 |
+| TFRecord | TFRecordDataset | TFRecord是TensorFlow定义的一种二进制数据文件格式。 |
+| NumPy | NumpySlicesDataset | NumPy数据源指的是已经读入内存中的NumPy arrays格式数据集。 |
| Text File | TextFileDataset | Text File指的是常见的文本格式数据。 |
| CSV File | CSVDataset | CSV指逗号分隔值，其文件以纯文本形式存储表格数据。 |
-MindSpore也同样支持使用GeneratorDataset自定义数据集的加载方式，用户可以根据需要实现自己的数据集类。
+MindSpore也同样支持使用`GeneratorDataset`自定义数据集的加载方式，用户可以根据需要实现自己的数据集类。
-更多详细的数据集加载接口说明，参见[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.html)。
+> 更多详细的数据集加载接口说明，参见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.dataset.html)。
-## 经典数据集加载
+## 常用数据集加载
-### MNIST数据集
+下面将介绍几种常用数据集的加载方式。
-```python
-# 通过MNIST API读取、解析MNIST数据集，并构建数据管道
-
-import mindspore.dataset as ds
+### CIFAR-10/100数据集
-# 下载MNIST数据集，将其解压到MnistData目录
-DATA_DIR = "MnistData/"
+下载[CIFAR-10数据集](https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz)并解压，目录结构如下。
-# 使用MnistDataset读取数据集，指定num_samples以获取5个样本数据
-# shuffle参数为True时，是随机获取5个样本，每次运行的label结果可能不一致
-dataset = ds.MnistDataset(DATA_DIR, num_samples=5, shuffle=True)
-
-# 启动数据管道，输出5个样本数据
-for data in dataset.create_dict_iterator():
- print("Image shape:", data['image'].shape, ", Label:", data['label'])
+```text
+└─cifar-10-batches-bin
+ ├── batches.meta.txt
+ ├── data_batch_1.bin
+ ├── data_batch_2.bin
+ ├── data_batch_3.bin
+ ├── data_batch_4.bin
+ ├── data_batch_5.bin
+ ├── readme.html
+ └── test_batch.bin
```
-```
-Image shape: (28, 28, 1) , Label: 4
-Image shape: (28, 28, 1) , Label: 9
-Image shape: (28, 28, 1) , Label: 4
-Image shape: (28, 28, 1) , Label: 0
-Image shape: (28, 28, 1) , Label: 9
-```
+下面的样例通过`Cifar10Dataset`接口加载CIFAR-10数据集，使用顺序采样器获取其中5个样本，然后展示了对应图片的形状和标签。
-### CIFAR10/100数据集
+CIFAR-100数据集和MNIST数据集的加载方式也与之类似。
```python
-# 通过Cifar API读取、解析CIFAR数据集，并构建数据管道（以CIFAR10数据集为例）
-
import mindspore.dataset as ds
-# 下载CIFAR10数据集，将其解压到CIFAR10Data目录
-DATA_DIR = "Cifar10Data/"
+DATA_DIR = "cifar-10-batches-bin/"
-# 指定一个顺序采样器SequentialSampler，按照读取顺序获取5个样本数据
sampler = ds.SequentialSampler(num_samples=5)
-
-# 使用CIFAR10Dataset读取数据集，指定sampler为上述采样器
dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 启动数据管道，输出5个样本数据
for data in dataset.create_dict_iterator():
print("Image shape:", data['image'].shape, ", Label:", data['label'])
```
-```
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 2
-Image shape: (32, 32, 3) , Label: 3
+输出结果如下：
+
+```text
+Image shape: (32, 32, 3) , Label: 6
+Image shape: (32, 32, 3) , Label: 9
+Image shape: (32, 32, 3) , Label: 9
Image shape: (32, 32, 3) , Label: 4
+Image shape: (32, 32, 3) , Label: 1
```
### VOC数据集
-```python
-# 通过VOC API读取、解析VOC数据集，并构建数据管道
+VOC数据集有多个版本，此处以VOC2012为例。下载[VOC2012数据集](http://host.robots.ox.ac.uk/pascal/VOC/voc2012/VOCtrainval_11-May-2012.tar)并解压，目录结构如下。
+
+```text
+└─ VOCtrainval_11-May-2012
+ └── VOCdevkit
+ └── VOC2012
+ ├── Annotations
+ ├── ImageSets
+ ├── JPEGImages
+ ├── SegmentationClass
+ └── SegmentationObject
+```
+下面的样例通过`VOCDataset`接口加载VOC2012数据集，分别演示了将任务指定为分割（Segmentation）和检测（Detection）时的原始图像形状和目标形状。
+
+```python
import mindspore.dataset as ds
-# 下载VOC数据集，将其解压到VOC2012目录
-DATA_DIR = "VOC2012/"
+DATA_DIR = "VOCtrainval_11-May-2012/VOCdevkit/VOC2012/"
+
+dataset = ds.VOCDataset(DATA_DIR, task="Segmentation", usage="train", num_samples=2, decode=True, shuffle=False)
-# 使用VOCDataset读取数据集，指定为Segmentation任务，同时指定num_samples以获取2个样本数据
-# decode参数会将读取的图像解码
-dataset = ds.VOCDataset(DATA_DIR, task="Segmentation", mode="train", num_samples=2, decode=True, shuffle=False)
print("[Segmentation]:")
for data in dataset.create_dict_iterator():
- # 原图像
print("image shape:", data["image"].shape)
- # 分割后图像
print("target shape:", data["target"].shape)
-# 接下来是Detection任务
-dataset = ds.VOCDataset(DATA_DIR, task="Detection", mode="train", num_samples=1, decode=True, shuffle=False)
+dataset = ds.VOCDataset(DATA_DIR, task="Detection", usage="train", num_samples=1, decode=True, shuffle=False)
+
print("[Detection]:")
for data in dataset.create_dict_iterator():
- # 原图像
print("image shape:", data["image"].shape)
- # 目标框
print("bbox shape:", data["bbox"].shape)
```
-```
+输出结果如下：
+
+```text
[Segmentation]:
image shape: (281, 500, 3)
target shape: (281, 500, 3)
@@ -155,196 +150,201 @@ bbox shape: (2, 4)
### COCO数据集
-```python
-# 通过Coco API读取、解析Coco数据集，并构建数据管道
+COCO数据集有多个版本，此处以COCO2017的验证数据集为例。下载COCO2017的[验证集](http://images.cocodataset.org/zips/val2017.zip)、[检测任务标注](http://images.cocodataset.org/annotations/annotations_trainval2017.zip)和[全景分割任务标注](http://images.cocodataset.org/annotations/panoptic_annotations_trainval2017.zip)并解压，只取其中的验证集部分，按以下目录结构存放。
+```text
+└─ COCO
+ ├── val2017
+ └── annotations
+ ├── instances_val2017.json
+ ├── panoptic_val2017.json
+ └── person_keypoints_val2017.json
+```
+
+下面的样例通过`CocoDataset`接口加载COCO2017数据集，分别演示了将任务指定为目标检测（Detection）、背景分割（Stuff）、关键点检测（Keypoint）和全景分割（Panoptic）时获取到的不同数据。
+
+```python
import mindspore.dataset as ds
-# 下载Coco数据集，将其解压到CocoData目录
-DATA_DIR = "COCO/train/"
-ANNOTATION_FILE = "COCO/annotations/train.json"
-KEYPOINT_FILE = "COCO/annotations/key_point.json"
-PANOPTIC_FILE = "COCO/annotations/panoptic.json"
+DATA_DIR = "COCO/val2017/"
+ANNOTATION_FILE = "COCO/annotations/instances_val2017.json"
+KEYPOINT_FILE = "COCO/annotations/person_keypoints_val2017.json"
+PANOPTIC_FILE = "COCO/annotations/panoptic_val2017.json"
-# 使用CocoDataset读取数据集，指定为Detection任务，同时指定num_samples以获取1个样本数据
dataset = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Detection", num_samples=1)
for data in dataset.create_dict_iterator():
print("Detection:", data.keys())
-# 让我们来观察一下，在指定Coco不同任务时，我们获取到的不同数据
-# Stuff 任务
dataset = ds.CocoDataset(DATA_DIR, annotation_file=ANNOTATION_FILE, task="Stuff", num_samples=1)
for data in dataset.create_dict_iterator():
print("Stuff:", data.keys())
-# Keypoint 任务
dataset = ds.CocoDataset(DATA_DIR, annotation_file=KEYPOINT_FILE, task="Keypoint", num_samples=1)
for data in dataset.create_dict_iterator():
print("Keypoint:", data.keys())
-# Panoptic 任务
dataset = ds.CocoDataset(DATA_DIR, annotation_file=PANOPTIC_FILE, task="Panoptic", num_samples=1)
for data in dataset.create_dict_iterator():
print("Panoptic:", data.keys())
```
-```
-Detection: dict_keys(['bbox', 'image', 'iscrowd', 'category_id'])
-Stuff: dict_keys(['segmentation', 'iscrowd', 'image'])
-Keypoint: dict_keys(['keypoints', 'num_keypoints', 'image'])
-Panoptic: dict_keys(['bbox', 'image', 'area', 'category_id', 'iscrowd'])
-```
+输出结果如下：
-> 更多经典数据集加载接口说明，参见对应[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.html)。
+```text
+Detection: dict_keys(['image', 'bbox', 'category_id', 'iscrowd'])
+Stuff: dict_keys(['image', 'segmentation', 'iscrowd'])
+Keypoint: dict_keys(['image', 'keypoints', 'num_keypoints'])
+Panoptic: dict_keys(['image', 'bbox', 'category_id', 'iscrowd', 'area'])
+```
## 特定格式数据集加载
+下面将介绍几种特定格式数据集文件的加载方式。
+
### MindRecord数据格式
-MindRecord是MindSpore的自研数据格式，具有更好的性能和特性。
+MindRecord是MindSpore定义的一种数据格式，使用MindRecord能够获得更好的性能提升。
+
+> 阅读[数据格式转换](https://www.mindspore.cn/doc/programming_guide/zh-CN/r1.0/dataset_conversion.html)章节，了解如何将数据集转化为MindSpore数据格式。
->阅读[数据格式转换](https://www.mindspore.cn/api/zh-CN/master/programming_guide/dataset_conversion.html)章节，了解如何将数据集转化为MindSpore数据格式。
+下面的样例通过`MindDataset`接口加载MindRecord文件，并展示已加载数据的标签。
```python
import mindspore.dataset as ds
-# 指定MindRecord数据格式地址
-DATA_DIR = "mindrecord_dataset_path"
-mindrecord_dataset = ds.MindDataset(DATA_DIR)
+DATA_FILE = ["mindrecord_file_0", "mindrecord_file_1", "mindrecord_file_2"]
+mindrecord_dataset = ds.MindDataset(DATA_FILE)
-# 启动数据管道读取
-for data in mindrecord_dataset.create_dict_iterator():
+for data in mindrecord_dataset.create_dict_iterator(output_numpy=True):
print(data["label"])
```
### Manifest数据格式
-Manifest是华为ModelArts支持的数据格式文件，详细说明请参见相关[文档](https://support.huaweicloud.com/engineers-modelarts/modelarts_23_0009.html)。
+Manifest是华为ModelArts支持的数据格式文件，详细说明请参见[Manifest文档](https://support.huaweicloud.com/engineers-modelarts/modelarts_23_0009.html)。
+
+下面的样例通过`ManifestDataset`接口加载Manifest文件，并展示已加载数据的标签。
```python
import mindspore.dataset as ds
-# 指定Manifest数据集地址
-DATA_DIR = "manifest_dataset_path"
-manifest_dataset = ds.ManifestDataset(DATA_DIR)
+DATA_FILE = "manifest_file"
+manifest_dataset = ds.ManifestDataset(DATA_FILE)
-# 启动数据管道读取
for data in manifest_dataset.create_dict_iterator():
print(data["label"])
```
### TFRecord数据格式
-TFRecord是Tensorflow定义的一种二进制数据文件格式。
+TFRecord是TensorFlow定义的一种二进制数据文件格式。
+
+下面的样例通过`TFRecordDataset`接口加载TFRecord文件，并介绍了两种不同的数据集格式设定方案。
-1. 传入数据集路径或`.tfrecord`文件列表，创建TFRecordDataset对象。
+1. 传入数据集路径或TFRecord文件列表，创建`TFRecordDataset`对象。
```python
import mindspore.dataset as ds
- DATA_DIR = "tfrecord_dataset_path"
- dataset = ds.TFRecordDataset(DATA_DIR)
+ DATA_FILE = ["tfrecord_file_0", "tfrecord_file_1", "tfrecord_file_2"]
+ tfrecord_dataset = ds.TFRecordDataset(DATA_FILE)
```
-2. 用户可以选择通过创建Schema文件或Schema类，设定数据集格式及特征。
-
- - 创建Schema文件
-
- Schema文件示例：
-
- ```
- {
- "datasetType": "TF",
- "numRows": 3,
- "columns": {
- "image": {
- "type": "uint8",
- "rank": 1
- },
- "label" : {
- "type": "int64",
- "rank": 1
+2. 用户可以通过编写Schema文件或创建Schema对象，设定数据集格式及特征。
+
+ - 编写Schema文件
+
+ 将数据集格式和特征按JSON格式写入Schema文件，示例如下：
+
+ ```json
+ {
+ "columns": {
+ "image": {
+ "type": "uint8",
+ "rank": 1
+ },
+ "label" : {
+ "type": "string",
+ "rank": 1
+ }
+ "id" : {
+ "type": "int64",
+ "rank": 0
+ }
}
}
- }
- ```
+ ```
- - `datasetType`: 数据格式的类型，这里`TF`是指TFrecord数据格式。
+ - `columns`：列信息字段，需要根据数据集的实际列名定义。上面的示例中，数据集列为`image`、`label`和`id`。
- - `columns`：列信息字段，需要根据数据集的实际列名定义，上面Schema文件示例中，数据集列为`image`和`label`两列。
+ 然后在创建`TFRecordDataset`时将Schema文件路径传入。
- - `numRows`：行数信息字段，控制加载数据的最大行数。如果定义的行数大于实际行数，加载时则以实际行数为准。
+ ```python
+ SCHEMA_DIR = "dataset_schema_path/schema.json"
+ tfrecord_dataset = ds.TFRecordDataset(DATA_FILE, schema=SCHEMA_DIR)
+ ```
- 在创建TFRecordDataset时将Schema文件路径传入。
+ - 创建Schema对象
- ```python
- DATA_DIR = "tfrecord_dataset_path"
- SCHEMA_DIR = "dataset_schema_path/schema.json"
- dataset = ds.TFRecordDataset(DATA_DIR, schema=SCHEMA_DIR)
- ```
+ 创建Schema对象，为其添加自定义字段，然后在创建数据集对象时传入。
- - 创建Schema类
+ ```python
+ import mindspore.common.dtype as mstype
+ schema = ds.Schema()
+ schema.add_column('image', de_type=mstype.uint8)
+ schema.add_column('label', de_type=mstype.int32)
+ tfrecord_dataset = ds.TFRecordDataset(DATA_FILE, schema=schema)
+ ```
- ```python
- import mindspore.common.dtype as mstype
- schema = ds.Schema()
- schema.add_column('image', de_type=mstype.uint8)
- schema.add_column('label', de_type=mstype.int32)
- dataset = ds.TFRecordDataset(DATA_DIR, schema=schema)
- ```
+### NumPy数据格式
-### Numpy数据格式
+如果所有数据已经读入内存，可以直接使用`NumpySlicesDataset`类将其加载。
-如果所有数据已经读入内存，可以直接使用NumpySlicesDataset类将其加载。
+下面的样例分别介绍了通过`NumpySlicesDataset`加载arrays数据、 list数据和dict数据的方式。
-- 加载Numpy arrays数据
+- 加载NumPy arrays数据
```python
- # 从Numpy arrays构建数据管道
-
import numpy as np
import mindspore.dataset as ds
- # 使用numpy构建一个数组
+ np.random.seed(58)
features, labels = np.random.sample((5, 2)), np.random.sample((5, 1))
- # 从numpy中构建数据管道
- # 注意：传入参数需要是一个tuple，即是(features, labels)；column_names用于指定生成的数据集名称为col1, col2
+
data = (features, labels)
dataset = ds.NumpySlicesDataset(data, column_names=["col1", "col2"], shuffle=False)
- # 启动数据管道
for data in dataset:
- print(data[0], " ", data[1])
+ print(data[0], data[1])
```
- ```
- [0.49893939 0.36348882] [0.15234002]
- [0.83845534 0.19721032] [0.94602561]
- [0.2361873 0.79506755] [0.88118559]
- [0.71856343 0.16168491] [0.55517421]
- [0.21266013 0.33411312] [0.74858382]
+ 输出结果如下：
+
+ ```text
+ [0.36510558 0.45120592] [0.78888122]
+ [0.49606035 0.07562207] [0.38068183]
+ [0.57176158 0.28963401] [0.16271622]
+ [0.30880446 0.37487617] [0.54738768]
+ [0.81585667 0.96883469] [0.77994068]
```
- 加载Python list数据
```python
- # 从Python list构建数据管道
import mindspore.dataset as ds
- # 构建一个list
data1 = [[1, 2], [3, 4]]
- # 从list中构建数据管道
- # column_names用于指定生成的数据集名称为col1
dataset = ds.NumpySlicesDataset(data1, column_names=["col1"], shuffle=False)
- # 启动数据管道
for data in dataset:
print(data[0])
```
- ```
+ 输出结果如下：
+
+ ```text
[1 2]
[3 4]
```
@@ -352,60 +352,42 @@ TFRecord是Tensorflow定义的一种二进制数据文件格式。
- 加载Python dict数据
```python
- # 从Python dict构建数据管道
-
import mindspore.dataset as ds
- # 构建一个dict
data1 = {"a": [1, 2], "b": [3, 4]}
- # 从dict中构建数据管道
- # column_names用于指定生成的数据集名称为col1, col2
dataset = ds.NumpySlicesDataset(data1, column_names=["col1", "col2"], shuffle=False)
- # 启动数据管道
for data in dataset.create_dict_iterator():
print(data)
```
- ```
- {'col1': array(1, dtype=int64), 'col2': array(3, dtype=int64)}
- {'col1': array(2, dtype=int64), 'col2': array(4, dtype=int64)}
- ```
+ 输出结果如下：
-### text数据格式
-
-```python
-import mindspore.dataset as ds
+ ```text
+ {'col1': Tensor(shape=[], dtype=Int64, value= 1), 'col2': Tensor(shape=[], dtype=Int64, value= 3)}
+ {'col1': Tensor(shape=[], dtype=Int64, value= 2), 'col2': Tensor(shape=[], dtype=Int64, value= 4)}
+ ```
-# 指定text数据格式地址
-DATA_DIR = "text_file_path"
-text_dataset = ds.TextFileDataset(DATA_DIR)
+### CSV数据格式
-# 启动数据管道读取
-for data in text_dataset.create_dict_iterator():
- print(data["label"])
-```
+下面的样例通过`CSVDataset`加载CSV格式数据集文件，并展示了已加载数据的标签。
-### CSV数据格式
+Text格式数据集文件的加载方式与CSV文件类似。
```python
import mindspore.dataset as ds
-# 指定CSV数据格式地址
-DATA_DIR = "csv_file_path"
-csv_dataset = ds.CSVDataset(DATA_DIR)
+DATA_FILE = ["csv_file_0", "csv_file_1", "csv_file_2"]
+csv_dataset = ds.CSVDataset(DATA_FILE)
-# 启动数据管道读取
-for data in csv_dataset.create_dict_iterator():
- print(data["label"])
+for data in csv_dataset.create_dict_iterator(output_numpy=True):
+ print(data["1"])
```
->更多数据格式文件加载说明，参见对应[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.html)。
-
## 自定义数据集加载
-对于目前MindSpore不支持直接加载的数据集，可以通过构造GeneratorDataset对象实现自定义方式的加载，或者将其转换成MindRecord数据格式。目前自定义数据集加载有以下几种方式。
+对于目前MindSpore不支持直接加载的数据集，可以通过构造`GeneratorDataset`对象实现自定义方式的加载，或者将其转换成MindRecord数据格式。目前自定义数据集加载有以下几种方式。
### 构造数据集生成函数
@@ -415,24 +397,23 @@ for data in csv_dataset.create_dict_iterator():
import numpy as np
import mindspore.dataset as ds
-# 随机生成一个数据集
np.random.seed(58)
data = np.random.sample((5, 2))
label = np.random.sample((5, 1))
-# 自定义数据返回方式
def GeneratorFunc():
for i in range(5):
yield (data[i], label[i])
-# 构建自定义数据集对象
dataset = ds.GeneratorDataset(GeneratorFunc, ["data", "label"])
-for data in dataset.create_dict_iterator():
- print(data["data"], data["label"])
+for sample in dataset.create_dict_iterator():
+ print(sample["data"], sample["label"])
```
-```
+输出结果如下：
+
+```text
[0.36510558 0.45120592] [0.78888122]
[0.49606035 0.07562207] [0.38068183]
[0.57176158 0.28963401] [0.16271622]
@@ -476,7 +457,9 @@ for data in dataset.create_dict_iterator():
print(data["data"], data["label"])
```
-```
+输出结果如下：
+
+```text
[0.36510558 0.45120592] [0.78888122]
[0.49606035 0.07562207] [0.38068183]
[0.57176158 0.28963401] [0.16271622]
@@ -511,7 +494,9 @@ for data in dataset.create_dict_iterator():
print(data["data"], data["label"])
```
-```
+输出结果如下：
+
+```text
[0.36510558 0.45120592] [0.78888122]
[0.49606035 0.07562207] [0.38068183]
[0.57176158 0.28963401] [0.16271622]
@@ -549,7 +534,9 @@ for data in dataset.create_dict_iterator():
print(data["data"], data["label"])
```
-```
+输出结果如下：
+
+```text
[0.36510558 0.45120592] [0.78888122]
[0.57176158 0.28963401] [0.16271622]
[0.81585667 0.96883469] [0.77994068]
diff --git a/docs/programming_guide/source_zh_cn/dtype.md b/docs/programming_guide/source_zh_cn/dtype.md
new file mode 100644
index 0000000000000000000000000000000000000000..c25ac7bfa5ce5da26087dc1d3a18df0c4acc56fa
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/dtype.md
@@ -0,0 +1,64 @@
+# dtype
+
+
+
+- [dtype](#dtype)
+ - [概述](#概述)
+ - [数据类型转换接口](#数据类型转换接口)
+
+
+
+
+
+## 概述
+
+MindSpore张量支持不同的数据类型，包含`int8`、`int16`、`int32`、`int64`、`uint8`、`uint16`、`uint32`、`uint64`、`float16`、`float32`、`float64`、`bool_`，与NumPy的数据类型一一对应。
+
+在MindSpore的运算处理流程中，Python中的`int`数会被转换为定义的int64类型，`float`数会被转换为定义的`float32`类型。
+
+详细的类型支持情况请参考
+
+基于MindSpore训练后的模型，支持在Ascend 910 AI处理器、Ascend 310 AI处理器、GPU、CPU、端侧等多种不同的平台上执行推理。使用方法可参考如下教程：
+
+- [在Ascend 910 AI处理器上执行推理](https://www.mindspore.cn/tutorial/inference/zh-CN/r1.0/multi_platform_inference_ascend_910.html)
+- [在Ascend 310 AI处理器上执行推理](https://www.mindspore.cn/tutorial/inference/zh-CN/r1.0/multi_platform_inference_ascend_310.html)
+- [在GPU上执行推理](https://www.mindspore.cn/tutorial/inference/zh-CN/r1.0/multi_platform_inference_gpu.html)
+- [在CPU上执行推理](https://www.mindspore.cn/tutorial/inference/zh-CN/r1.0/multi_platform_inference_cpu.html)
+- [在端侧执行推理](https://www.mindspore.cn/tutorial/lite/zh-CN/r1.0/quick_start/quick_start.html)
+
+同时，MindSpore提供了一个轻量级、高性能的服务模块，称为MindSpore Serving，可帮助MindSpore开发者在生产环境中高效部署在线推理服务，使用方法可参考[部署推理服务](https://www.mindspore.cn/tutorial/inference/zh-CN/r1.0/serving.html)。
diff --git a/api/source_zh_cn/programming_guide/component.md b/docs/programming_guide/source_zh_cn/network_component.md
similarity index 72%
rename from api/source_zh_cn/programming_guide/component.md
rename to docs/programming_guide/source_zh_cn/network_component.md
index dd92ce5515f63c12a6e11d84c3b8648734f94c8f..8a6d249a7a3501cafa94d98e9eff835fc6713b4e 100644
--- a/api/source_zh_cn/programming_guide/component.md
+++ b/docs/programming_guide/source_zh_cn/network_component.md
@@ -4,41 +4,41 @@
- [常用网络组件](#常用网络组件)
- [概述](#概述)
- - [GradOperation](#GradOperation)
- - [WithLossCell](#WithLossCell)
- - [TrainOneStepCell](#TrainOneStepCell)
+ - [GradOperation](#gradoperation)
+ - [WithLossCell](#withlosscell)
+ - [TrainOneStepCell](#trainonestepcell)
+
+
## 概述
-MindSpore封装一些常用的网络组件，用于网络的训练，推理，求梯度和数据处理等。
+MindSpore封装了一些常用的网络组件，用于网络的训练、推理、求梯度和数据处理等操作。
这些网络组件可以直接被用户使用，同样也会在`model.train`和`model.eval`等更高级的封装接口内部进行使用。
-本节内容将会介绍三个网络组件，分别是`GradOperation`，`WithLossCell`和`TrainOneStepCell`，将会从功能，用户使用和内部使用三个方面来进行介绍。
-
+本节内容将会介绍三个网络组件，分别是`GradOperation`、`WithLossCell`和`TrainOneStepCell`，将会从功能、用户使用和内部使用三个方面来进行介绍。
+
## GradOperation
-GradOperation组件用于生成输入函数的梯度，利用`get_all`，`get_by_list`和`sens_param`参数
-控制梯度的计算方式，细节内容详见API文档。
+GradOperation组件用于生成输入函数的梯度，利用`get_all`、`get_by_list`和`sens_param`参数控制梯度的计算方式，细节内容详见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GradOperation)。
GradOperation的使用实例如下：
-```
+```python
import numpy as np
import mindspore.nn as nn
from mindspore import Tensor, Parameter
from mindspore.common import dtype as mstype
-from mindspore.ops import composite as C
-from mindspore.ops import operations as P
+import mindspore.ops as ops
class Net(nn.Cell):
def __init__(self):
super(Net, self).__init__()
- self.matmul = P.MatMul()
+ self.matmul = ops.MatMul()
self.z = Parameter(Tensor(np.array([1.0], np.float32)), name='z')
def construct(self, x, y):
x = x * self.z
@@ -49,7 +49,7 @@ class GradNetWrtX(nn.Cell):
def __init__(self, net):
super(GradNetWrtX, self).__init__()
self.net = net
- self.grad_op = C.GradOperation()
+ self.grad_op = ops.GradOperation()
def construct(self, x, y):
gradient_function = self.grad_op(self.net)
return gradient_function(x, y)
@@ -59,13 +59,11 @@ y = Tensor([[0.01, 0.3, 1.1], [0.1, 0.2, 1.3], [2.1, 1.2, 3.3]], dtype=mstype.fl
GradNetWrtX(Net())(x, y)
```
-上面的例子是计算`Net`相对与x的梯度值，首先需要定义网络`Net`作为`GradOperation`的输入，
-实例创建了包含梯度运算的`GradNetWrtX`。调用`GradNetWrtX`是将网络传入`GradOperation`生成梯度函数，
-将输入数据传入梯度函数中返回最终结果。
+上面的例子是计算`Net`相对与x的梯度值，首先需要定义网络`Net`作为`GradOperation`的输入，实例创建了包含梯度运算的`GradNetWrtX`。调用`GradNetWrtX`是将网络传入`GradOperation`生成梯度函数，将输入数据传入梯度函数中返回最终结果。
输出如下：
-```
+```text
Tensor(shape=[2, 3], dtype=Float32,
[[1.4100001 1.5999999 6.6 ]
[1.4100001 1.5999999 6.6 ]])
@@ -76,11 +74,11 @@ MindSpore涉及梯度计算的其他组件，例如`WithGradCell`和`TrainOneSte
## WithLossCell
-`WithLossCell`本质上是一个包含损失函数的`Cell`, 构造`WithLossCell`需要事先定义好网络和损失函数。
+`WithLossCell`本质上是一个包含损失函数的`Cell`，构造`WithLossCell`需要事先定义好网络和损失函数。
下面通过一个实例来介绍其具体的使用， 首先需要构造一个网络，内容如下：
-```
+```python
import numpy as np
import pytest
@@ -89,7 +87,7 @@ import mindspore.nn as nn
from mindspore import Tensor
from mindspore.nn import TrainOneStepCell, WithLossCell
from mindspore.nn.optim import Momentum
-from mindspore.ops import operations as P
+import mindspore.ops as ops
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
@@ -97,13 +95,13 @@ context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
class LeNet(nn.Cell):
def __init__(self):
super(LeNet, self).__init__()
- self.relu = P.ReLU()
+ self.relu = ops.ReLU()
self.batch_size = 32
self.conv1 = nn.Conv2d(1, 6, kernel_size=5, stride=1, padding=0, has_bias=False, pad_mode='valid')
self.conv2 = nn.Conv2d(6, 16, kernel_size=5, stride=1, padding=0, has_bias=False, pad_mode='valid')
self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
- self.reshape = P.Reshape()
+ self.reshape = ops.Reshape()
self.fc1 = nn.Dense(400, 120)
self.fc2 = nn.Dense(120, 84)
self.fc3 = nn.Dense(84, 10)
@@ -124,21 +122,22 @@ class LeNet(nn.Cell):
return output
```
-下面是`WithLossCell`的使用实例，分别定义好网络和损失函数，然后创建一个`WithLossCell`，
-然后传入输入数据和标签数据，`WithLossCell`内部根据网络和损失函数返回计算结果
-```
+下面是`WithLossCell`的使用实例，分别定义好网络和损失函数，然后创建一个`WithLossCell`，传入输入数据和标签数据，`WithLossCell`内部根据网络和损失函数返回计算结果。
+
+```python
data = Tensor(np.ones([32, 1, 32, 32]).astype(np.float32) * 0.01)
label = Tensor(np.ones([32]).astype(np.int32))
net = LeNet()
-criterion = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
+criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
net_with_criterion = WithLossCell(net, criterion)
loss = net_with_criterion(data, label)
print("+++++++++Loss+++++++++++++")
print(loss)
```
-输出结果如下：
-```
+输出如下：
+
+```text
+++++++++Loss+++++++++++++
2.302585
```
@@ -149,7 +148,7 @@ print(loss)
下面构造一个使用`TrainOneStepCell`接口进行网络训练的实例，其中`LeNet`和包名的导入代码和上个用例共用。
-```
+```python
data = Tensor(np.ones([32, 1, 32, 32]).astype(np.float32) * 0.01)
label = Tensor(np.ones([32]).astype(np.int32))
net = LeNet()
@@ -157,7 +156,7 @@ learning_rate = 0.01
momentum = 0.9
optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), learning_rate, momentum)
-criterion = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
+criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
net_with_criterion = WithLossCell(net, criterion)
train_network = TrainOneStepCell(net_with_criterion, optimizer) # optimizer
for i in range(5):
@@ -167,11 +166,11 @@ for i in range(5):
print(res)
```
-用例中构造了优化器和一个`WithLossCell`的实例，然后传入`TrainOneStepCell` 中初始化一个训练网络，用例循环五次，相当于网络训练了五次，
-并输出每次的loss结果，由结果可以看出每次训练后loss值在逐渐减小。
+用例中构造了优化器和一个`WithLossCell`的实例，然后传入`TrainOneStepCell`中初始化一个训练网络，用例循环五次，相当于网络训练了五次，并输出每次的loss结果，由结果可以看出每次训练后loss值在逐渐减小。
-输出结果如下：
-```
+输出如下：
+
+```text
+++++++++result:0++++++++++++
2.302585
+++++++++result:1++++++++++++
@@ -183,5 +182,6 @@ for i in range(5):
+++++++++result:4++++++++++++
2.2215357
```
+
后续内容会介绍MindSpore使用更加高级封装的接口，即`Model`类中的`train`方法训练模型，在其内部实现中会用到
`TrainOneStepCell`和`WithLossCell` 等许多网络组件，感兴趣的读者可以查看其内部实现。
diff --git a/docs/programming_guide/source_zh_cn/network_list.rst b/docs/programming_guide/source_zh_cn/network_list.rst
new file mode 100644
index 0000000000000000000000000000000000000000..9f3f23bd00ff952ef7824cbc149905a4c64ce876
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/network_list.rst
@@ -0,0 +1,7 @@
+网络支持
+===========
+
+.. toctree::
+ :maxdepth: 1
+
+ MindSpore网络支持
+
+## 概述
+
+MindSpore的算子组件，可从算子使用方式和算子功能两种维度进行划分。
+
+## 算子使用方式
+
+算子相关接口主要包括operations、functional和composite，可通过ops直接获取到这三类算子。
+
+- operations提供单个的Primtive算子。一个算子对应一个原语，是最小的执行对象，需要实例化之后使用。
+- composite提供一些预定义的组合算子，以及复杂的涉及图变换的算子，如`GradOperation`。
+- functional提供operations和composite实例化后的对象，简化算子的调用流程。
+
+### mindspore.ops.operations
+
+operations提供了所有的Primitive算子接口，是开放给用户的最低阶算子接口。算子支持情况可查询[算子支持列表](https://www.mindspore.cn/doc/note/zh-CN/r1.0/operator_list.html)。
+
+Primitive算子也称为算子原语，它直接封装了底层的Ascend、GPU、AICPU、CPU等多种算子的具体实现，为用户提供基础算子能力。
+
+Primitive算子接口是构建高阶接口、自动微分、网络模型等能力的基础。
+
+代码样例如下：
+
+```python
+import numpy as np
+import mindspore
+from mindspore import Tensor
+import mindspore.ops.operations as P
+
+input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+input_y = 3.0
+pow = P.Pow()
+output = pow(input_x, input_y)
+print("output =", output)
+```
+
+输出如下：
+
+```text
+output = [ 1. 8. 64.]
+```
+
+### mindspore.ops.functional
+
+为了简化没有属性的算子的调用流程，MindSpore提供了一些算子的functional版本。入参要求参考原算子的输入输出要求。算子支持情况可以查询[算子支持列表](https://www.mindspore.cn/doc/note/zh-CN/r1.0/operator_list_ms.html#mindspore-ops-functional)。
+
+例如`P.Pow`算子，我们提供了functional版本的`F.tensor_pow`算子。
+
+使用functional的代码样例如下：
+
+```python
+import numpy as np
+import mindspore
+from mindspore import Tensor
+from mindspore.ops import functional as F
+
+input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+input_y = 3.0
+output = F.tensor_pow(input_x, input_y)
+print("output =", output)
+```
+
+输出如下：
+
+```text
+output = [ 1. 8. 64.]
+```
+
+### mindspore.ops.composite
+
+composite提供了一些算子的组合，包括clip_by_value和random相关的一些算子，以及涉及图变换的函数（`GradOperation`、`HyperMap`和`Map`等）。
+
+算子的组合可以直接像一般函数一样使用，例如使用`normal`生成一个随机分布：
+
+```python
+from mindspore.common import dtype as mstype
+from mindspore.ops import composite as C
+from mindspore import Tensor
+
+mean = Tensor(1.0, mstype.float32)
+stddev = Tensor(1.0, mstype.float32)
+output = C.normal((2, 3), mean, stddev, seed=5)
+print("ouput =", output)
+```
+
+输出如下：
+
+```text
+output = [[2.4911082 0.7941146 1.3117087]
+ [0.30582333 1.772938 1.525996]]
+```
+
+> 以上代码运行于MindSpore的GPU版本。
+
+针对涉及图变换的函数，用户可以使用`MultitypeFuncGraph`定义一组重载的函数，根据不同类型，采用不同实现。
+
+代码样例如下：
+
+```python
+import numpy as np
+from mindspore.ops.composite import MultitypeFuncGraph
+from mindspore import Tensor
+import mindspore.ops as ops
+
+add = MultitypeFuncGraph('add')
+@add.register("Number", "Number")
+def add_scalar(x, y):
+ return ops.scalar_add(x, y)
+
+@add.register("Tensor", "Tensor")
+def add_tensor(x, y):
+ return ops.tensor_add(x, y)
+
+tensor1 = Tensor(np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32'))
+tensor2 = Tensor(np.array([[1.2, 2.1], [2.2, 3.2]]).astype('float32'))
+print('tensor', add(tensor1, tensor2))
+print('scalar', add(1, 2))
+```
+
+输出如下：
+
+```text
+tensor [[2.4, 4.2]
+ [4.4, 6.4]]
+scalar 3
+```
+
+此外，高阶函数`GradOperation`提供了根据输入的函数，求这个函数对应的梯度函数的方式，详细可以参阅[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.ops.html#mindspore.ops.GradOperation)。
+
+### operations/functional/composite三类算子合并用法
+
+为了在使用过程中更加简便，除了以上介绍的几种用法外，我们还将operations/functional/composite三种算子封装到了mindspore.ops中，推荐直接调用mindspore.ops下的接口。
+
+代码样例如下：
+
+```python
+import mindspore.ops.operations as P
+pow = P.Pow()
+```
+
+```python
+import mindspore.ops as ops
+pow = ops.Pow()
+```
+
+> 以上两种写法效果相同。
+
+## 算子功能
+
+算子按功能可分为张量操作、网络操作、数组操作、图像操作、编码操作、调试操作和量化操作七个功能模块。所有的算子在Ascend AI处理器、GPU和CPU的支持情况，参见[算子支持列表](https://www.mindspore.cn/doc/note/zh-CN/r1.0/operator_list.html)。
+
+### 张量操作
+
+张量操作包括张量的结构操作和张量的数学运算。
+
+张量结构操作有：张量创建、索引切片、维度变换和合并分割。
+
+张量数学运算有：标量运算、向量运算和矩阵运算。
+
+这里以张量的数学运算和运算的广播机制为例，介绍使用方法。
+
+### 标量运算
+
+张量的数学运算符可以分为标量运算符、向量运算符以及矩阵运算符。
+
+加减乘除乘方，以及三角函数、指数、对数等常见函数，逻辑比较运算符等都是标量运算符。
+
+标量运算符的特点是对张量实施逐元素运算。
+
+有些标量运算符对常用的数学运算符进行了重载。并且支持类似NumPy的广播特性。
+
+ 以下代码实现了对input_x作乘方数为input_y的乘方操作：
+
+```python
+import numpy as np
+import mindspore
+from mindspore import Tensor
+
+input_x = mindspore.Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+input_y = 3.0
+print(input_x**input_y)
+```
+
+ 输出如下：
+
+```text
+[ 1. 8. 64.]
+```
+
+#### 加法
+
+上述代码中`input_x`和`input_y`的相加实现方式如下：
+
+```python
+print(input_x + input_y)
+```
+
+ 输出如下：
+
+```text
+[4.0 5.0 7.0]
+```
+
+#### Element-wise乘法
+
+以下代码实现了Element-wise乘法示例：
+
+```python
+import numpy as np
+import mindspore
+from mindspore import Tensor
+import mindspore.ops as ops
+
+input_x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+input_y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
+mul = ops.Mul()
+res = mul(input_x, input_y)
+
+print(res)
+```
+
+ 输出如下：
+
+```text
+[4. 10. 18]
+```
+
+#### 求三角函数
+
+以下代码实现了Acos：
+
+```python
+import numpy as np
+import mindspore
+from mindspore import Tensor
+import mindspore.ops as ops
+
+acos = ops.ACos()
+input_x = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+output = acos(input_x)
+print(output)
+```
+
+ 输出如下：
+
+```text
+[0.7377037, 1.5307858, 1.2661037，0.97641146]
+```
+
+### 向量运算
+
+向量运算符只在一个特定轴上运算，将一个向量映射到一个标量或者另外一个向量。
+
+#### Squeeze
+
+以下代码实现了压缩第3个通道维度为1的通道：
+
+```python
+import numpy as np
+import mindspore
+from mindspore import Tensor
+import mindspore.ops as ops
+
+input_tensor = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
+squeeze = ops.Squeeze(2)
+output = squeeze(input_tensor)
+
+print(output)
+```
+
+ 输出如下：
+
+```text
+[[1. 1.]
+ [1. 1.]
+ [1. 1.]]
+```
+
+### 矩阵运算
+
+矩阵运算包括矩阵乘法、矩阵范数、矩阵行列式、矩阵求特征值、矩阵分解等运算。
+
+#### 矩阵乘法
+
+ 以下代码实现了input_x 和 input_y的矩阵乘法：
+
+```python
+import numpy as np
+import mindspore
+from mindspore import Tensor
+import mindspore.ops as ops
+
+input_x = Tensor(np.ones(shape=[1, 3]), mindspore.float32)
+input_y = Tensor(np.ones(shape=[3, 4]), mindspore.float32)
+matmul = ops.MatMul()
+output = matmul(input_x, input_y)
+
+print(output)
+```
+
+输出如下：
+
+```text
+[[3. 3. 3. 3.]]
+```
+
+#### 广播机制
+
+广播表示输入各变量channel数目不一致时，改变他们的channel数以得到结果。
+
+- 以下代码实现了广播机制的示例：
+
+```python
+from mindspore import Tensor
+from mindspore.communication import init
+from mindspore import nn
+import mindspore.ops as ops
+import numpy as np
+
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.broadcast = ops.Broadcast(1)
+
+ def construct(self, x):
+ return self.broadcast((x,))
+
+input_ = Tensor(np.ones([2, 8]).astype(np.float32))
+net = Net()
+output = net(input_)
+```
+
+### 网络操作
+
+网络操作包括特征提取、激活函数、LossFunction、优化算法等。
+
+#### 特征提取
+
+特征提取是机器学习中的常见操作，核心是提取比原输入更具代表性的Tensor。
+
+卷积操作
+
+以下代码实现了常见卷积操作之一的2D convolution 操作：
+
+```python
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore
+
+input = Tensor(np.ones([10, 32, 32, 32]), mindspore.float32)
+weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
+conv2d = ops.Conv2D(out_channel=32, kernel_size=3)
+res = conv2d(input, weight)
+
+print(res)
+```
+
+输出如下：
+
+```text
+[[[[288. 288. 288. ... 288. 288. 288.]
+ [288. 288. 288. ... 288. 288. 288.]
+ [288. 288. 288. ... 288. 288. 288.]
+ ...
+ [288. 288. 288. ... 288. 288. 288.]
+ [288. 288. 288. ... 288. 288. 288.]
+ [288. 288. 288. ... 288. 288. 288.]]
+
+ ...
+ [288. 288. 288. ... 288. 288. 288.]
+ [288. 288. 288. ... 288. 288. 288.]
+ [288. 288. 288. ... 288. 288. 288.]]]]
+```
+
+卷积的反向传播算子操作
+
+以下代码实现了反向梯度算子传播操作的具体代码，输出存于dout， weight：
+
+```python
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore
+
+dout = Tensor(np.ones([10, 32, 30, 30]), mindspore.float32)
+weight = Tensor(np.ones([32, 32, 3, 3]), mindspore.float32)
+x = Tensor(np.ones([10, 32, 32, 32]))
+conv2d_backprop_input = ops.Conv2DBackpropInput(out_channel=32, kernel_size=3)
+res = conv2d_backprop_input(dout, weight, ops.shape(x))
+
+print(res)
+```
+
+输出如下：
+
+```text
+[[[[ 32. 64. 96. ... 96. 64. 32.]
+ [ 64. 128. 192. ... 192. 128. 64.]
+ [ 96. 192. 288. ... 288. 192. 96.]
+ ...
+ [ 96. 192. 288. ... 288. 192. 96.]
+ [ 64. 128. 192. ... 192. 128. 64.]
+ [ 32. 64. 96. ... 96. 64. 32.]]
+
+ [[ 32. 64. 96. ... 96. 64. 32.]
+ [ 64. 128. 192. ... 192. 128. 64.]
+ [ 96. 192. 288. ... 288. 192. 96.]
+ ...
+ [ 96. 192. 288. ... 288. 192. 96.]
+ [ 64. 128. 192. ... 192. 128. 64.]
+ [ 32. 64. 96. ... 96. 64. 32.]]]]
+```
+
+#### 激活函数
+
+以下代码实现Softmax激活函数计算：
+
+```python
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore
+
+input_x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
+softmax = ops.Softmax()
+res = softmax(input_x)
+
+print(res)
+```
+
+输出如下：
+
+```text
+[0.01165623 0.03168492 0.08612854 0.23412167 0.6364086]
+```
+
+#### LossFunction
+
+ 以下代码实现了L1 loss function：
+
+```python
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore
+
+loss = ops.SmoothL1Loss()
+input_data = Tensor(np.array([1, 2, 3]), mindspore.float32)
+target_data = Tensor(np.array([1, 2, 2]), mindspore.float32)
+res = loss(input_data, target_data)
+print(res)
+```
+
+ 输出如下：
+
+```text
+[0. 0. 0.5]
+```
+
+#### 优化算法
+
+ 以下代码实现了SGD梯度下降算法的具体实现，输出是result：
+
+```python
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore
+
+sgd = ops.SGD()
+parameters = Tensor(np.array([2, -0.5, 1.7, 4]), mindspore.float32)
+gradient = Tensor(np.array([1, -1, 0.5, 2]), mindspore.float32)
+learning_rate = Tensor(0.01, mindspore.float32)
+accum = Tensor(np.array([0.1, 0.3, -0.2, -0.1]), mindspore.float32)
+momentum = Tensor(0.1, mindspore.float32)
+stat = Tensor(np.array([1.5, -0.3, 0.2, -0.7]), mindspore.float32)
+result = sgd(parameters, gradient, learning_rate, accum, momentum, stat)
+
+print(result)
+```
+
+ 输出如下：
+
+```text
+[0. 0. 0. 0.]
+```
+
+### 数组操作
+
+数组操作指操作对象是一些数组的操作。
+
+#### DType
+
+返回跟输入的数据类型一致的并且适配Mindspore的Tensor变量，常用于Mindspore工程内。
+
+具体可参见示例：
+
+```python
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore
+
+input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
+typea = ops.DType()(input_tensor)
+
+print(typea)
+```
+
+ 输出如下：
+
+```text
+Float32
+```
+
+#### Cast
+
+转换输入的数据类型并且输出与目标数据类型相同的变量。
+
+具体参见以下示例：
+
+```python
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore
+
+input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
+input_x = Tensor(input_np)
+type_dst = mindspore.float16
+cast = ops.Cast()
+result = cast(input_x, type_dst)
+print(type(result))
+```
+
+ 输出结果:
+
+```text
+
+
## 概述
-mindSpore.nn.optim是Mindspore框架中实现各种优化算法的模块，包含常用的优化器，学习率等，并且接口具备足够的通用性，可以将以后更新、更复杂的方法集成到模块里。
+`mindspore.nn.optim`是MindSpore框架中实现各种优化算法的模块，包含常用的优化器、学习率等，并且接口具备足够的通用性，可以将以后更新、更复杂的方法集成到模块里。
-mindspore.nn.optim为模型提供常用的优化器，如SGD、ADAM、Momentum。优化器用于计算和更新梯度，模型优化算法的选择直接关系到最终模型的性能，如果有时候效果不好，未必是特征或者模型设计的问题，很有可能是优化算法的问题；
-同时还有mindspore.nn提供的学习率的模块，学习率learing_rate分为dynamic_lr和learning_rate_schedule，都是动态学习率，但是实现方式不同，学习率最为监督学习以及深度学习中重要的参数，其决定着目标函数是否能收敛到局部最小值以及何时能收敛到最小值。
-合适的学习率能够使目标函数在合适的的时间内收敛到局部最小值。
+`mindspore.nn.optim`为模型提供常用的优化器，如`SGD`、`ADAM`、`Momentum`。优化器用于计算和更新梯度，模型优化算法的选择直接关系到最终模型的性能，如果有时候效果不好，未必是特征或者模型设计的问题，很有可能是优化算法的问题；同时还有`mindspore.nn`提供的学习率的模块，学习率分为`dynamic_lr`和`learning_rate_schedule`，都是动态学习率，但是实现方式不同，学习率是监督学习以及深度学习中最为重要的参数，其决定着目标函数是否能收敛到局部最小值以及何时能收敛到最小值。合适的学习率能够使目标函数在合适的的时间内收敛到局部最小值。
> 本文档中的所有示例，支持CPU，GPU，Ascend环境。
## 学习率
+
### dynamic_lr
-mindspore.nn.dynamic_lr模块有以下几个类，piecewise_constant_lr类是得到分段不变的学习速率，exponential_decay_lr类是基于指数衰减函数计算学习率，natural_exp_decay_lr类是基于自然指数衰减函数计算学习率，inverse_decay_lr类是基于反时间衰减函数计算学习速率，cosine_decay_lr类是基于余弦衰减函数计算学习率，polynomial_decay_lr类是基于多项式衰减函数计算学习率，warmup_lr类是提高学习率，它们是属于dynamic_lr的不同实现方式。
+`mindspore.nn.dynamic_lr`模块有以下几个类：
-例如piecewise_constant_lr类代码样例如下：
+- `piecewise_constant_lr`类：基于得到分段不变的学习速率。
+- `exponential_decay_lr`类：基于指数衰减函数计算学习率。
+- `natural_exp_decay_lr`类：基于自然指数衰减函数计算学习率。
+- `inverse_decay_lr`类：基于反时间衰减函数计算学习速率。
+- `cosine_decay_lr`类：基于余弦衰减函数计算学习率。
+- `polynomial_decay_lr`类：基于多项式衰减函数计算学习率。
+- `warmup_lr`类：提高学习率。
-```
-class mindspore.nn.dynamic_lr.piecewise_constant_lr(milestone, learning_rates)
+它们是属于`dynamic_lr`的不同实现方式。
-Parameters:
- milestone (Union[list[int], tuple[int]]) – A list of milestone. This list is a monotone increasing list. Every element is a milestone step, and must be greater than 0.
- learning_rates (Union[list[float], tuple[float]]) – A list of learning rates.
+例如`piecewise_constant_lr`类代码样例如下：
-Returns:
- list[float]. The size of list
-```
+```python
+from mindspore.nn.dynamic_lr import piecewise_constant_lr
-```
-milestone = [2, 5, 10]
-learning_rates = [0.1, 0.05, 0.01]
-piecewise_constant_lr(milestone, learning_rates)
+def test_dynamic_lr():
+ milestone = [2, 5, 10]
+ learning_rates = [0.1, 0.05, 0.01]
+ lr = piecewise_constant_lr(milestone, learning_rates)
+ print(lr)
+
+
+if __name__ == '__main__':
+ test_dynamic_lr()
```
返回结果如下：
-```
+
+```text
[0.1, 0.1, 0.05, 0.05, 0.05, 0.01, 0.01, 0.01, 0.01, 0.01]
```
### learning_rate_schedule
-mindspore.nn.learning_rate_schedule模块下有以下几个类。ExponentialDecayLR类，NaturalExpDecayLR类，InverseDecayLR类，CosineDecayLR类，PolynomialDecayLR类，WarmUpLR类。它们都属于learning_rate_schedule，只是实现方式不同。
+`mindspore.nn.learning_rate_schedule`模块下有以下几个类：`ExponentialDecayLR`类、`NaturalExpDecayLR`类、`InverseDecayLR`类、`CosineDecayLR`类、`PolynomialDecayLR`类和`WarmUpLR`类。它们都属于`learning_rate_schedule`，只是实现方式不同，各自含义如下：
+
+- `ExponentialDecayLR`类：基于指数衰减函数计算学习率。
+- `NaturalExpDecayLR`类：基于自然指数衰减函数计算学习率。
+- `InverseDecayLR`类：基于反时间衰减函数计算学习速率。
+- `CosineDecayLR`类：基于余弦衰减函数计算学习率。
+- `PolynomialDecayLR`类：基于多项式衰减函数计算学习率。
+- `WarmUpLR`类：提高学习率。
-ExponentialDecayLR类是基于指数衰减函数计算学习率，NaturalExpDecayLR类是基于自然指数衰减函数巨酸学习率,InverseDecayLR类是基于反时间衰减函数计算学习速率，CosineDecayLR类是基于余弦衰减函数计算学习率，PolynomialDecayLR类是基于多项式衰减函数计算学习率，WarmUpLR类是提高学习率，它们是属于learning_rate_schedule的不同实现方式。
+它们是属于`learning_rate_schedule`的不同实现方式。
例如ExponentialDecayLR类代码样例如下：
-```
-class ExponentialDecayLR(learning_rate, decay_rate, decay_steps, is_stair=False)
-Parameters:
- learning_rate(float) - The initial value of learning rate.
- decay_rate(float) - The decay rate.
- decay_steps(int) - A value used to calculate decayed learning rate.
- is_stair(bool) - if true,learning rate decay once every decay_steps times. Default: False.
+```python
+from mindspore.common import dtype as mstype
+from mindspore import Tensor
+from mindspore.nn.learning_rate_schedule import ExponentialDecayLR
-inputs:
- Tensor.The current step number.
+def test_learning_rate_schedule():
+ learning_rate = 0.1 # learning_rate(float) - The initial value of learning rate.
+ decay_rate = 0.9 # decay_rate(float) - The decay rate.
+ decay_steps = 4 # decay_steps(int) - A value used to calculate decayed learning rate.
+ global_step = Tensor(2, mstype.int32)
+ exponential_decay_lr = ExponentialDecayLR(learning_rate, decay_rate, decay_steps)
+ res = exponential_decay_lr(global_step)
+ print(res)
-Returns:
- Tensor. The learning rate value for the current step.
-```
+if __name__ == '__main__':
+ test_learning_rate_schedule()
```
-from mindspore.common import dtype as mstype
-from mindspore import Tensor
-
-learning_rate = 0.1 # learning_rate(float) - The initial value of learning rate.
-decay_rate = 0.9 # decay_rate(float) - The decay rate.
-decay_steps = 4 # decay_steps(int) - A value used to calculate decayed learning rate.
-global_step = Tensor(2, mystype.int32)
-exponential_decay_lr = ExponentialDecayLR(learning_rate, decay_rate, decay_steps)
-exponential_decay_lr(global_step)
+返回结果如下：
+```text
+0.094868325
```
+## Optimzer
-## optimzer
### 如何使用
-为了使用mindspore.nn.optim，我们需要构建一个optimizer对象。这个对象能够保持当前参数状态并基于计算得到的梯度进行参数更新。
+
+为了使用`mindspore.nn.optim`，我们需要构建一个`Optimizer`对象。这个对象能够保持当前参数状态并基于计算得到的梯度进行参数更新。
- 构建
-为了构建一个Optimizer，我们需要给它一个包含可需要优化的参数（必须是Variable对象）的iterable。然后，你可以设置optimizer的参数选项，比如学习率，权重衰减等等。
+为了构建一个`Optimizer`，我们需要给它一个包含可需要优化的参数（必须是Variable对象）的iterable。然后，你可以设置Optimizer的参数选项，比如学习率，权重衰减等等。
代码样例如下：
-```
+```python
from mindspore import nn
optim = nn.SGD(group_params, learning_rate=0.1, weight_decay=0.0)
@@ -114,12 +125,12 @@ optim = nn.Adam(group_params, learning_rate=0.1, weight_decay=0.0)
- 为每一个参数单独设置选项
-优化器也支持为没个参数单独设置选项。若想这么做，不要直接传入变量Variable，而是传入一个字典的iterable。每一个字典都分别定义了一组参数，并且包含一个key键，这个key键对应相应的参数value值。其他的key键应该是优化器所接受的其他参数，并且会被用于对这组参数的优化。
+优化器也支持为每个参数单独设置选项。若想这么做，不要直接传入变量Variable，而是传入一个字典的iterable。每一个字典都分别定义了一组参数，并且包含一个key键，这个key键对应相应的参数value值。其他的key键应该是优化器所接受的其他参数，并且会被用于对这组参数的优化。
我们仍然能够传递选项作为关键字参数，在未重写这些选项的组中，它们会被用作默认值。当你只想改动一个参数组的选项，但其他参数组的选项不变时，这是非常有用的。
-例如，当我们想制定每一层的学习率时，以SGD为例：
+例如，当我们想制定每一层的学习率时，以`SGD`为例：
-```
+```python
from mindspore import nn
optim = nn.SGD([{'params': conv_params, 'weight_decay': 0.01},
@@ -128,26 +139,41 @@ optim = nn.SGD([{'params': conv_params, 'weight_decay': 0.01},
learning_rate=0.1, weight_decay=0.0)
```
+
这段示例意味着当参数是conv_params时候，权重衰减使用的是0.01，学习率使用的是0.1；而参数是no_conv_params时候，权重衰减使用的是0.0，学习率使用的是0.01。这个学习率learning_rate=0.1会被用于所有分组里没有设置学习率的参数，权重衰减weight_deca也是如此。
### 内置优化器
-深度学习优化算法大概常用的有SGD、Adam、Ftrl、lazyadam、Momentum、RMSprop、Lars、Proximal_ada_grad和lamb这几种。
-在mindspore.nn.optim模块中，他们都有对应的类实现。例如：
+深度学习优化算法大概常用的有`SGD`、`Adam`、`Ftrl`、`lazyadam`、`Momentum`、`RMSprop`、`Lars`、`Proximal_ada_grad`和`lamb`这几种。
+在`mindspore.nn.optim`模块中，他们都有对应的类实现。例如：
-- SGD，默认参数为纯SGD，设置momentum参数不为0，考虑了一阶动量，设置nesterov为True后变成NAG，即Nesterov Accelerated Gradient，在计算梯度时计算的是向前走一步所在位置的梯度。
+- `SGD`，默认参数为纯SGD，设置`momentum`参数不为0，考虑了一阶动量，设置`nesterov`为True后变成`NAG`，即`Nesterov Accelerated Gradient`，在计算梯度时计算的是向前走一步所在位置的梯度。
-- RMSprop，考虑了二阶动量，对于不同的参数有不同的学习率，即自适应学习率，对Adagrad进行了优化，通过指数平滑只考虑一定窗口内的二阶动量。
+- `RMSprop`，考虑了二阶动量，对于不同的参数有不同的学习率，即自适应学习率，对`Adagrad`进行了优化，通过指数平滑只考虑一定窗口内的二阶动量。
-- Adam，同时考虑了一阶动量和二阶动量，可以看成RMSprop上进一步考虑了一阶动量。
+- `Adam`，同时考虑了一阶动量和二阶动量，可以看成`RMSprop`上进一步考虑了一阶动量。
-例如SGD的代码样例如下：
+例如`SGD`的代码样例如下：
-```
+```python
from mindspore import nn
from mindspore.train import Model
from .optimizer import Optimizer
-
+from mindspore import Tensor
+import mindspore.ops as ops
+import numpy as np
+import mindspore.common.dtype as mstype
+from mindspore.common.parameter import Parameter
+
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.matmul = ops.MatMul()
+ self.z = Parameter(Tensor(np.array([1.0], np.float32)), name='z')
+ def construct(self, x, y):
+ x = x * self.z
+ out = self.matmul(x, y)
+ return out
net = Net()
optim = nn.SGD(params=net.trainable_params())
@@ -162,4 +188,4 @@ optim = nn.SGD(group_params, learning_rate=0.1, weight_decay=0.0)
loss = nn.SoftmaxCrossEntropyWithLogits()
model = Model(net, loss_fn=loss, optimizer=optim)
-```
\ No newline at end of file
+```
diff --git a/api/source_zh_cn/programming_guide/parameter.md b/docs/programming_guide/source_zh_cn/parameter.md
similarity index 67%
rename from api/source_zh_cn/programming_guide/parameter.md
rename to docs/programming_guide/source_zh_cn/parameter.md
index 4e6bf70213746377f7f22d2107e006205143f2b4..246985d0cadebdd92dfbd4d427c84e5aa616bb6e 100644
--- a/api/source_zh_cn/programming_guide/parameter.md
+++ b/docs/programming_guide/source_zh_cn/parameter.md
@@ -6,39 +6,42 @@
- [概述](#概述)
- [初始化](#初始化)
- [属性](#属性)
- - [接口](#方法)
+ - [方法](#方法)
- [ParameterTuple](#parametertuple)
-
-
-
+
## 概述
-Parameter是变量张量，代表在训练网络时，需要被更新的参数，是MetaTensor的一个子类。
+`Parameter`是变量张量，代表在训练网络时，需要被更新的参数。本章主要介绍了`Parameter`的初始化以及属性和方法的使用，同时介绍了`ParameterTuple`。
## 初始化
+
+```python
+mindspore.Parameter(default_input, name, requires_grad=True, layerwise_parallel=False)
```
-def __init__(self, default_input, name, requires_grad=True, layerwise_parallel=False)
-```
+
初始化一个`Parameter`对象，传入的数据支持`Tensor`、`Initializer`、`int`和`float`四种类型。
-`Initializer`是初始化器，保存了shape和dtype信息，可调用`to_tensor`方法生成存有数据的Tensor。
+`Initializer`是初始化器，保存了shape和dtype信息，提供`to_tensor`方法生成存有数据的`Tensor`，可调用`initializer`接口生成`Initializer`对象。
-当网络采用半自动或者全自动并行策略，并且使用`Initializer`初始化`Parameter`时，
-`Parameter`里保存的不是`Tensor`，而是`MetaTensor`。
+当网络采用半自动或者全自动并行策略，并且使用`Initializer`初始化`Parameter`时，`Parameter`里保存的不是`Tensor`，而是`MetaTensor`。
-`MetaTensor`与`Tensor`不同，`MetaTensor`仅保存张量的形状和类型，而不保存实际数据，
-所以不会占用任何内存，可调用`init_data`接口将`Parameter`里保存的`MetaTensor`转化为`Tensor`。
+`MetaTensor`与`Tensor`不同，`MetaTensor`仅保存张量的形状和类型，而不保存实际数据，所以不会占用任何内存，可调用`init_data`接口将`Parameter`里保存的`MetaTensor`转化为`Tensor`。
可为每个`Parameter`指定一个名称，便于后续操作和更新。
-当`layerwise_parallel`为`True`时，参数广播和参数梯度聚合时会过滤掉该参数。
+当参数需要被更新时，需要将`requires_grad`设置为`True`。
+
+当`layerwise_parallel`（混合并行）配置为True时，参数广播和参数梯度聚合时会过滤掉该参数。
+
+有关分布式并行的相关配置，可以参考文档：
+
+MindSpore提供了多种性能优化方法，用户可根据实际情况，利用它们来提升训练和推理的性能。
+
+| 优化阶段 | 优化方法 | 支持情况 |
+| --- | --- | --- |
+| 训练 | [分布式并行训练](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/distributed_training_tutorials.html) | Ascend、GPU |
+| | [混合精度](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/enable_mixed_precision.html) | Ascend、GPU |
+| | [图算融合](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/enable_graph_kernel_fusion.html) | Ascend |
+| | [梯度累积](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/apply_gradient_accumulation.html) | Ascend、GPU |
+| 推理 | [训练后量化](https://www.mindspore.cn/tutorial/lite/zh-CN/r1.0/use/post_training_quantization.html) | Lite |
diff --git a/api/source_zh_cn/programming_guide/pipeline.md b/docs/programming_guide/source_zh_cn/pipeline.md
similarity index 51%
rename from api/source_zh_cn/programming_guide/pipeline.md
rename to docs/programming_guide/source_zh_cn/pipeline.md
index bd8af3408a74be9594ed762832502cdcbf10cec9..41e1486a951ed0a979b8f82cd35cf30ce5824386 100644
--- a/api/source_zh_cn/programming_guide/pipeline.md
+++ b/docs/programming_guide/source_zh_cn/pipeline.md
@@ -11,11 +11,10 @@
- [repeat](#repeat)
- [zip](#zip)
- [concat](#concat)
- - [project](#project)
-
+
## 概述
@@ -23,7 +22,7 @@
MindSpore的各个数据集类都为用户提供了多种数据处理算子，用户可以构建数据处理pipeline定义需要使用的数据处理操作，数据即可在训练过程中像水一样源源不断地经过数据处理pipeline流向训练系统。
-MindSpore目前支持的常用数据处理算子如下表所示，更多数据处理操作参见[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.html)。
+MindSpore目前支持的常用数据处理算子如下表所示，更多数据处理操作参见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.dataset.html)。
| 数据处理算子 | 算子说明 |
| ---- | ---- |
@@ -45,54 +44,49 @@ MindSpore目前支持的常用数据处理算子如下表所示，更多数据
-```python
-# 将数据集进行混洗操作
+下面的样例先构建了一个随机数据集，然后对其进行混洗操作，最后展示了混洗后的数据结果。
+```python
import numpy as np
import mindspore.dataset as ds
-# 设置全局随机种子，确保shuffle的行为可预测
ds.config.set_seed(0)
-# 构建一个generator
def generator_func():
for i in range(5):
yield (np.array([i, i+1, i+2]),)
-# 从generator中构建数据管道
dataset1 = ds.GeneratorDataset(generator_func, ["data"])
-# 为数据集创建一个混洗操作
-# buffer_size代表创建一个存放size个样本的容器，再从此容器中随机采样样本进行输出
-# 当buffer_size设置为dataset的长度时，是全局混洗
dataset1 = dataset1.shuffle(buffer_size=2)
for data in dataset1.create_dict_iterator():
print(data)
```
-```
-{'data': array([0, 1, 2], dtype=int64)}
-{'data': array([2, 3, 4], dtype=int64)}
-{'data': array([3, 4, 5], dtype=int64)}
-{'data': array([1, 2, 3], dtype=int64)}
-{'data': array([4, 5, 6], dtype=int64)}
+输出结果如下：
+
+```text
+{'data': Tensor(shape=[3], dtype=Int64, value=[0, 1, 2])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[2, 3, 4])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[3, 4, 5])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[1, 2, 3])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[4, 5, 6])}
```
### map
将指定的函数或算子作用于数据集的指定列数据，实现数据映射操作。用户可以自定义映射函数，也可以直接使用c_transforms或py_transforms中的算子针对图像、文本数据进行数据增强。
->更多数据增强的使用说明，参见编程指南中[数据增强](https://www.mindspore.cn/api/zh-CN/master/programming_guide/augmentation.html)章节。
+>更多数据增强的使用说明，参见编程指南中[数据增强](https://www.mindspore.cn/doc/programming_guide/zh-CN/r1.0/augmentation.html)章节。
-```python
-# 将数据集进行映射操作
+下面的样例先构建了一个随机数据集，然后定义了数据翻倍的映射函数并将其作用于数据集，最后对比展示了映射前后的数据结果。
+```python
import numpy as np
import mindspore.dataset as ds
-# 构建一个generator
def generator_func():
for i in range(5):
yield (np.array([i, i+1, i+2]),)
@@ -100,36 +94,33 @@ def generator_func():
def pyfunc(x):
return x*2
-# 从generator中构建数据管道
dataset = ds.GeneratorDataset(generator_func, ["data"])
-# 创建数据管道，输出原始数据
for data in dataset.create_dict_iterator():
print(data)
-print("")
+print("------ after processing ------")
-# 为数据集创建一个映射操作
-# input_columns指定要处理的列，operation指定映射函数
-dataset = dataset.map(input_columns=["data"], operations=pyfunc)
+dataset = dataset.map(operations=pyfunc, input_columns=["data"])
-# 创建数据管道，输出映射后的数据
for data in dataset.create_dict_iterator():
print(data)
```
-```
-{'data': array([0, 1, 2], dtype=int64)}
-{'data': array([1, 2, 3], dtype=int64)}
-{'data': array([2, 3, 4], dtype=int64)}
-{'data': array([3, 4, 5], dtype=int64)}
-{'data': array([4, 5, 6], dtype=int64)}
-
-{'data': array([0, 2, 4], dtype=int64)}
-{'data': array([2, 4, 6], dtype=int64)}
-{'data': array([4, 6, 8], dtype=int64)}
-{'data': array([ 6, 8, 10], dtype=int64)}
-{'data': array([ 8, 10, 12], dtype=int64)}
+输出结果如下：
+
+```text
+{'data': Tensor(shape=[3], dtype=Int64, value=[0, 1, 2])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[1, 2, 3])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[2, 3, 4])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[3, 4, 5])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[4, 5, 6])}
+------ after processing ------
+{'data': Tensor(shape=[3], dtype=Int64, value=[0, 2, 4])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[2, 4, 6])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[4, 6, 8])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[ 6, 8, 10])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[ 8, 10, 12])}
```
### batch
@@ -138,45 +129,40 @@ for data in dataset.create_dict_iterator():
-```python
-# 将数据集进行分批操作
+下面的样例先构建了一个随机数据集，然后分别展示了保留多余数据与否的数据集分批结果，其中批大小为2。
+```python
import numpy as np
import mindspore.dataset as ds
-# 构建一个generator
def generator_func():
for i in range(5):
yield (np.array([i, i+1, i+2]),)
-# 从generator中构建数据管道
dataset1 = ds.GeneratorDataset(generator_func, ["data"])
-# 为数据集划分批次，batch_size代表每2个样本为一个批次
-# drop_remainder代表是否丢弃最后不能完整构成批次的样本
-# 在此例子中，5%2=1，但因为drop_remainder=False，因此保留最后一个单独的样本
dataset1 = dataset1.batch(batch_size=2, drop_remainder=False)
for data in dataset1.create_dict_iterator():
print(data)
-print("")
+print("------ drop remainder ------")
-# 从generator中构建数据管道
dataset2 = ds.GeneratorDataset(generator_func, ["data"])
-# 丢弃最后不能完整构成批次的样本
dataset2 = dataset2.batch(batch_size=2, drop_remainder=True)
for data in dataset2.create_dict_iterator():
print(data)
```
-```
-{'data': array([[0, 1, 2], [1, 2, 3]], dtype=int64)}
-{'data': array([[2, 3, 4], [3, 4, 5]], dtype=int64)}
-{'data': array([[4, 5, 6]], dtype=int64)}
+输出结果如下：
-{'data': array([[0, 1, 2], [1, 2, 3]], dtype=int64)}
-{'data': array([[2, 3, 4], [3, 4, 5]], dtype=int64)}
+```text
+{'data': Tensor(shape=[2, 3], dtype=Int64, value=[[0, 1, 2], [1, 2, 3]])}
+{'data': Tensor(shape=[2, 3], dtype=Int64, value=[[2, 3, 4], [3, 4, 5]])}
+{'data': Tensor(shape=[1, 3], dtype=Int64, value=[[4, 5, 6]])}
+------ drop remainder ------
+{'data': Tensor(shape=[2, 3], dtype=Int64, value=[[0, 1, 2], [1, 2, 3]])}
+{'data': Tensor(shape=[2, 3], dtype=Int64, value=[[2, 3, 4], [3, 4, 5]])}
```
### repeat
@@ -187,38 +173,36 @@ for data in dataset2.create_dict_iterator():
-```python
-# 将数据集进行加倍操作
+下面的样例先构建了一个随机数据集，然后将其重复2次，最后展示了重复后的数据结果。
+```python
import numpy as np
import mindspore.dataset as ds
-# 构建一个generator
def generator_func():
for i in range(5):
yield (np.array([i, i+1, i+2]),)
-# 从generator中构建数据管道
dataset1 = ds.GeneratorDataset(generator_func, ["data"])
-# 为数据集创建一个加倍操作
-# count参数代表将数据集内容扩充为原来的count倍
dataset1 = dataset1.repeat(count=2)
for data in dataset1.create_dict_iterator():
print(data)
```
-```
-{'data': array([0, 1, 2], dtype=int64)}
-{'data': array([1, 2, 3], dtype=int64)}
-{'data': array([2, 3, 4], dtype=int64)}
-{'data': array([3, 4, 5], dtype=int64)}
-{'data': array([4, 5, 6], dtype=int64)}
-{'data': array([0, 1, 2], dtype=int64)}
-{'data': array([1, 2, 3], dtype=int64)}
-{'data': array([2, 3, 4], dtype=int64)}
-{'data': array([3, 4, 5], dtype=int64)}
-{'data': array([4, 5, 6], dtype=int64)}
+输出结果如下：
+
+```text
+{'data': Tensor(shape=[3], dtype=Int64, value=[0, 1, 2])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[1, 2, 3])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[2, 3, 4])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[3, 4, 5])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[4, 5, 6])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[0, 1, 2])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[1, 2, 3])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[2, 3, 4])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[3, 4, 5])}
+{'data': Tensor(shape=[3], dtype=Int64, value=[4, 5, 6])}
```
### zip
@@ -230,39 +214,36 @@ for data in dataset1.create_dict_iterator():
-```python
-# 将数据集进行合并操作
+下面的样例先构建了两个不同样本数的随机数据集，然后将其进行列拼接，最后展示了拼接后的数据结果。
+```python
import numpy as np
import mindspore.dataset as ds
-# 构建一个generator
def generator_func():
for i in range(7):
yield (np.array([i, i+1, i+2]),)
-# 构建另一个generator
def generator_func2():
for i in range(4):
yield (np.array([1, 2]),)
-# 从generator中构建数据管道
dataset1 = ds.GeneratorDataset(generator_func, ["data1"])
dataset2 = ds.GeneratorDataset(generator_func2, ["data2"])
-# 为数据集创建一个合并操作
-# 新的dataset3会拥有2个列名，分别为data1，data2，同时因为data2的数据较少，会与data2的数据长度对齐
dataset3 = ds.zip((dataset1, dataset2))
for data in dataset3.create_dict_iterator():
print(data)
```
-```
-{'data1': array([0, 1, 2], dtype=int64), 'data2': array([1, 2], dtype=int64)}
-{'data1': array([1, 2, 3], dtype=int64), 'data2': array([1, 2], dtype=int64)}
-{'data1': array([2, 3, 4], dtype=int64), 'data2': array([1, 2], dtype=int64)}
-{'data1': array([3, 4, 5], dtype=int64), 'data2': array([1, 2], dtype=int64)}
+输出结果如下：
+
+```text
+{'data1': Tensor(shape=[3], dtype=Int64, value= [0, 1, 2]), 'data2': Tensor(shape=[2], dtype=Int64, value= [1, 2])}
+{'data1': Tensor(shape=[3], dtype=Int64, value= [1, 2, 3]), 'data2': Tensor(shape=[2], dtype=Int64, value= [1, 2])}
+{'data1': Tensor(shape=[3], dtype=Int64, value= [2, 3, 4]), 'data2': Tensor(shape=[2], dtype=Int64, value= [1, 2])}
+{'data1': Tensor(shape=[3], dtype=Int64, value= [3, 4, 5]), 'data2': Tensor(shape=[2], dtype=Int64, value= [1, 2])}
```
### concat
@@ -273,84 +254,34 @@ for data in dataset3.create_dict_iterator():
-```python
-# 将数据集进行连接操作
+下面的样例先构建了两个随机数据集，然后将其进行行拼接，最后展示了拼接后的数据结果。值得一提的是，使用`+`运算符也能达到同样的效果。
+```python
import numpy as np
import mindspore.dataset as ds
-# 构建一个generator
def generator_func():
for i in range(2):
yield (np.array([0, 0, 0]),)
-# 构建另一个generator
def generator_func2():
for i in range(2):
yield (np.array([1, 2, 3]),)
-# 从generator中构建数据管道
dataset1 = ds.GeneratorDataset(generator_func, ["data1"])
dataset2 = ds.GeneratorDataset(generator_func2, ["data1"])
-# 为数据集创建一个连接操作，将dataset2合并到dataset1的data1列中
dataset3 = dataset1.concat(dataset2)
-# 值得一提的是，使用'+'运算符可以达到上面同样的效果
-# dataset3 = dataset1 + dataset2
-
for data in dataset3.create_dict_iterator():
print(data)
-
-```
-
-```
-{'data1': array([0, 0, 0], dtype=int64)}
-{'data1': array([0, 0, 0], dtype=int64)}
-{'data1': array([1, 2, 3], dtype=int64)}
-{'data1': array([1, 2, 3], dtype=int64)}
```
-### project
-
-对数据集列进行映射，将指定列按顺序保留并向下传递到数据管道中，其余列将被丢弃。
-
->`project`还可以用于改变column排列的顺序！
-
-
-
-```python
-# 将数据集进行投影操作
-
-import numpy as np
-import mindspore.dataset as ds
-
-# 构建一个generator
-def generator_func():
- for i in range(2):
- yield (np.array([1, 2, 3]), np.array([7, 8, 9]), )
-
-# 从generator中构建数据管道
-dataset = ds.GeneratorDataset(generator_func, ["data1", "data2"])
-
-# 构建数据管道，获得原始数据
-for data in dataset.create_dict_iterator():
- print(data)
-
-print("")
-
-# 为数据集创建一个投影操作，只保留data1的数据
-dataset = dataset.project(columns=["data1"])
-
-# 构建数据管道，获得投影后的数据
-for data in dataset.create_dict_iterator():
- print(data)
-```
-
-```
-{'data1': array([1, 2, 3], dtype=int64), 'data2': array([7, 8, 9], dtype=int64)}
-{'data1': array([1, 2, 3], dtype=int64), 'data2': array([7, 8, 9], dtype=int64)}
+输出结果如下：
-{'data1': array([1, 2, 3], dtype=int64)}
-{'data1': array([1, 2, 3], dtype=int64)}
+```text
+{'data1': Tensor(shape=[3], dtype=Int64, value= [0, 0, 0])}
+{'data1': Tensor(shape=[3], dtype=Int64, value= [0, 0, 0])}
+{'data1': Tensor(shape=[3], dtype=Int64, value= [1, 2, 3])}
+{'data1': Tensor(shape=[3], dtype=Int64, value= [1, 2, 3])}
```
diff --git a/docs/programming_guide/source_zh_cn/probability.md b/docs/programming_guide/source_zh_cn/probability.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b7e0c150bcdd4d0d69914d0afa93b59c73d8c90
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/probability.md
@@ -0,0 +1,1068 @@
+# 深度概率编程库
+
+
+
+- [深度概率编程库](#深度概率编程库)
+ - [概率分布](#概率分布)
+ - [概率分布类](#概率分布类)
+ - [Distribution基类](#distribution基类)
+ - [伯努利分布(Bernoulli)](#伯努利分布bernoulli)
+ - [指数分布(Exponential)](#指数分布exponential)
+ - [几何分布(Geometric)](#几何分布geometric)
+ - [正态分布(Normal)](#正态分布normal)
+ - [均匀分布(Uniform)](#均匀分布uniform)
+ - [概率分布类在PyNative模式下的应用](#概率分布类在pynative模式下的应用)
+ - [概率分布类在图模式下的应用](#概率分布类在图模式下的应用)
+ - [TransformedDistribution类接口设计](#transformeddistribution类接口设计)
+ - [PyNative模式下调用TransformedDistribution实例](#pynative模式下调用transformeddistribution实例)
+ - [图模式下调用TransformedDistribution实例](#图模式下调用transformeddistribution实例)
+ - [概率分布映射](#概率分布映射)
+ - [Bijector类接口设计](#bijector类接口设计)
+ - [Bijector基类](#bijector基类)
+ - [幂函数变换映射(PowerTransform)](#幂函数变换映射powertransform)
+ - [指数变换映射(Exp)](#指数变换映射exp)
+ - [标量仿射变换映射(ScalarAffine)](#标量仿射变换映射scalaraffine)
+ - [Softplus变换映射(Softplus)](#softplus变换映射softplus)
+ - [PyNative模式下调用Bijector实例](#pynative模式下调用bijector实例)
+ - [图模式下调用Bijector实例](#图模式下调用bijector实例)
+ - [深度概率网络](#深度概率网络)
+ - [VAE](#vae)
+ - [ConditionalVAE](#conditionalvae)
+ - [概率推断算法](#概率推断算法)
+ - [贝叶斯层](#贝叶斯层)
+ - [贝叶斯转换](#贝叶斯转换)
+ - [贝叶斯工具箱](#贝叶斯工具箱)
+
+
+
+
+
+MindSpore深度概率编程的目标是将深度学习和贝叶斯学习结合，包括概率分布、概率分布映射、深度概率网络、概率推断算法、贝叶斯层、贝叶斯转换和贝叶斯工具箱，面向不同的开发者。对于专业的贝叶斯学习用户，提供概率采样、推理算法和模型构建库；另一方面，为不熟悉贝叶斯深度学习的用户提供了高级的API，从而不用更改深度学习编程逻辑，即可利用贝叶斯模型。
+
+## 概率分布
+
+概率分布（`mindspore.nn.probability.distribution`）是概率编程的基础。`Distribution` 类提供多样的概率统计接口，例如概率密度函数 *pdf* 、累积密度函数 *cdf* 、散度计算 *kl_loss* 、抽样 *sample* 等。现有的概率分布实例包括高斯分布，伯努利分布，指数型分布，几何分布和均匀分布。
+
+### 概率分布类
+
+- `Distribution`：所有概率分布的基类。
+
+- `Bernoulli`：伯努利分布。参数为试验成功的概率。
+
+- `Exponential`： 指数型分布。参数为率参数。
+
+- `Geometric`：几何分布。参数为一次伯努利试验成功的概率。
+
+- `Normal`：正态（高斯）分布。参数为均值和标准差。
+
+- `Uniform`：均匀分布。参数为数轴上的最小值和最大值。
+
+#### Distribution基类
+
+`Distribution` 是所有概率分布的基类。
+
+接口介绍：`Distribution` 类支持的函数包括 `prob`、`log_prob`、`cdf`、`log_cdf`、`survival_function`、`log_survival`、`mean`、`sd`、`var`、`entropy`、`kl_loss`、`cross_entropy` 和 `sample` 。分布不同，所需传入的参数也不同。只有在派生类中才能使用，由派生类的函数实现决定参数。
+
+- `prob` ：概率密度函数（PDF）/ 概率质量函数（PMF）。
+- `log_prob` ：对数似然函数。
+- `cdf` ：累积分布函数（CDF）。
+- `log_cdf` ：对数累积分布函数。
+- `survival_function` ：生存函数。
+- `log_survival` ：对数生存函数。
+- `mean` ：均值。
+- `sd` ：标准差。
+- `var` ：方差。
+- `entropy` ：熵。
+- `kl_loss` ：Kullback-Leibler 散度。
+- `cross_entropy` ：两个概率分布的交叉熵。
+- `sample` ：概率分布的随机抽样。
+
+#### 伯努利分布(Bernoulli)
+
+伯努利分布，继承自 `Distribution` 类。
+
+属性:
+
+- `Bernoulli.probs`：伯努利试验成功的概率。
+
+`Distribution` 基类调用 `Bernoulli` 中私有接口以实现基类中的公有接口。`Bernoulli` 支持的公有接口为：
+
+- `mean`，`mode`，`var`：可选择传入 试验成功的概率 *probs1* 。
+- `entropy`：可选择传入 试验成功的概率 *probs1* 。
+- `cross_entropy`，`kl_loss`：必须传入 *dist* 和 *probs1_b* 。*dist* 为另一分布的类型，目前只支持此处为 *‘Bernoulli’* 。 *probs1_b* 为分布 *b* 的试验成功概率。可选择传入分布 *a* 的参数 *probs1_a* 。
+- `prob`，`log_prob`，`cdf`，`log_cdf`，`survival_function`，`log_survival`：必须传入 *value* 。可选择传入试验成功的概率 *probs* 。
+- `sample`：可选择传入样本形状 *shape* 和试验成功的概率 *probs1* 。
+
+#### 指数分布(Exponential)
+
+指数分布，继承自 `Distribution` 类。
+
+属性:
+
+- `Exponential.rate`：率参数。
+
+`Distribution` 基类调用 `Exponential` 私有接口以实现基类中的公有接口。`Exponential` 支持的公有接口为：
+
+- `mean`，`mode`，`var`：可选择传入率参数 *rate* 。
+- `entropy`：可选择传入率参数 *rate* 。
+- `cross_entropy`，`kl_loss`：必须传入 *dist* 和 *rate_b* 。 *dist* 为另一分布的类型的名称， 目前只支持此处为 *‘Exponential’* 。*rate_b* 为分布 *b* 的率参数。可选择传入分布 *a* 的参数 *rate_a* 。
+- `prob`，`log_prob`，`cdf`，`log_cdf`，`survival_function`，`log_survival`：必须传入 *value* 。可选择传入率参数 *rate* 。
+- `sample`：可选择传入样本形状 *shape* 和率参数 *rate* 。
+
+#### 几何分布(Geometric)
+
+几何分布，继承自 `Distribution` 类。
+
+属性:
+
+- `Geometric.probs`：伯努利试验成功的概率。
+
+`Distribution` 基类调用 `Geometric` 中私有接口以实现基类中的公有接口。`Geometric` 支持的公有接口为：
+
+- `mean`，`mode`，`var`：可选择传入 试验成功的概率 *probs1* 。
+- `entropy`：可选择传入 试验成功的概率 *probs1* 。
+- `cross_entropy`，`kl_loss`：必须传入 *dist* 和 *probs1_b* 。*dist* 为另一分布的类型的名称，目前只支持此处为 *‘Geometric’* 。 *probs1_b* 为分布 *b* 的试验成功概率。可选择传入分布 *a* 的参数 *probs1_a* 。
+- `prob`，`log_prob`，`cdf`，`log_cdf`，`survival_function`，`log_survival`：必须传入 *value* 。可选择传入试验成功的概率 *probs1* 。
+- `sample`：可选择传入样本形状 *shape* 和试验成功的概率 *probs1* 。
+
+#### 正态分布(Normal)
+
+正态（高斯）分布，继承自 `Distribution` 类。
+
+`Distribution` 基类调用 `Normal` 中私有接口以实现基类中的公有接口。`Normal` 支持的公有接口为：
+
+- `mean`，`mode`，`var`：可选择传入分布的参数均值 *mean* 和标准差 *sd* 。
+- `entropy`：可选择传入分布的参数均值 *mean* 和标准差 *sd* 。
+- `cross_entropy`，`kl_loss`：必须传入 *dist* ，*mean_b* 和 *sd_b* 。*dist* 为另一分布的类型的名称，目前只支持此处为 *‘Normal’* 。*mean_b* 和 *sd_b* 为分布 *b* 的均值和标准差。可选择传入分布的参数 *a* 均值 *mean_a* 和标准差 *sd_a* 。
+- `prob`，`log_prob`，`cdf`，`log_cdf`，`survival_function`，`log_survival`：必须传入 *value* 。可选择分布的参数包括均值 *mean_a* 和标准差 *sd_a* 。
+- `sample`：可选择传入样本形状 *shape* 和分布的参数包括均值 *mean_a* 和标准差 *sd_a* 。
+
+#### 均匀分布(Uniform)
+
+均匀分布，继承自 `Distribution` 类。
+
+属性:
+
+- `Uniform.low`：最小值。
+- `Uniform.high`：最大值。
+
+`Distribution` 基类调用 `Uniform` 以实现基类中的公有接口。`Uniform` 支持的公有接口为：
+
+- `mean`，`mode`，`var`：可选择传入分布的参数最大值 *high* 和最小值 *low* 。
+- `entropy`：可选择传入分布的参数最大值 *high* 和最小值 *low* 。
+- `cross_entropy`，`kl_loss`：必须传入 *dist* ，*high_b* 和 *low_b* 。*dist* 为另一分布的类型的名称，目前只支持此处为 *‘Uniform’* 。 *high_b* 和 *low_b* 为分布 *b* 的参数。可选择传入分布 *a* 的参数即最大值 *high_a* 和最小值 *low_a* 。
+- `prob`，`log_prob`，`cdf`，`log_cdf`，`survival_function`，`log_survival`：必须传入 *value* 。可选择传入分布的参数最大值 *high* 和最小值 *low* 。
+- `sample`：可选择传入 *shape* 和分布的参数即最大值 *high* 和最小值 *low* 。
+
+### 概率分布类在PyNative模式下的应用
+
+`Distribution` 子类可在 **PyNative** 模式下使用。
+
+导入相关模块：
+
+```python
+from mindspore import Tensor
+from mindspore import dtype as mstype
+import mindspore.context as context
+import mindspore.nn.probability.distribution as msd
+context.set_context(mode=context.PYNATIVE_MODE)
+```
+
+以 `Normal` 为例， 创建一个均值为0.0、标准差为1.0的正态分布：
+
+```python
+my_normal = msd.Normal(0.0, 1.0, dtype=mstype.float32)
+```
+
+计算均值：
+
+```python
+mean = my_normal.mean()
+print(mean)
+```
+
+输出为：
+
+```python
+0.0
+```
+
+计算方差：
+
+```python
+var = my_normal.var()
+print(var)
+```
+
+输出为：
+
+```python
+1.0
+```
+
+计算熵：
+
+```python
+entropy = my_normal.entropy()
+print(entropy)
+```
+
+输出为：
+
+```python
+1.4189385
+```
+
+计算概率密度函数：
+
+```python
+value = Tensor([-0.5, 0.0, 0.5], dtype=mstype.float32)
+prob = my_normal.prob(value)
+print(prob)
+```
+
+输出为：
+
+```python
+[0.35206532, 0.3989423, 0.35206532]
+```
+
+计算累积分布函数：
+
+```python
+cdf = my_normal.cdf(value)
+print(cdf)
+```
+
+输出为：
+
+```python
+[0.30852754, 0.5, 0.69146246]
+```
+
+计算 Kullback-Leibler 散度：
+
+```python
+mean_b = Tensor(1.0, dtype=mstype.float32)
+sd_b = Tensor(2.0, dtype=mstype.float32)
+kl = my_normal.kl_loss('Normal', mean_b, sd_b)
+print(kl)
+```
+
+输出为：
+
+```python
+0.44314718
+```
+
+### 概率分布类在图模式下的应用
+
+在图模式下，`Distribution` 子类可用在网络中。
+
+导入相关模块：
+
+```python
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore import dtype as mstype
+import mindspore.context as context
+import mindspore.nn.probability.distribution as msd
+context.set_context(mode=context.GRAPH_MODE)
+```
+
+创建网络：
+
+```python
+# 网络继承nn.Cell
+class Net(nn.Cell):
+ def __init__(self):
+ super(Net, self).__init__()
+ self.normal = msd.Normal(0.0, 1.0, dtype=mstype.float32)
+
+ def construct(self, value, mean, sd):
+ pdf = self.normal.prob(value)
+ kl = self.normal.kl_loss("Normal", mean, sd)
+ return pdf, kl
+```
+
+调用网络：
+
+```python
+net = Net()
+value = Tensor([-0.5, 0.0, 0.5], dtype=mstype.float32)
+mean = Tensor(1.0, dtype=mstype.float32)
+sd = Tensor(1.0, dtype=mstype.float32)
+pdf, kl = net(value, mean, sd)
+print("pdf: ", pdf)
+print("kl: ", kl)
+```
+
+输出为：
+
+```python
+pdf: [0.3520653, 0.39894226, 0.3520653]
+kl: 0.5
+```
+
+### TransformedDistribution类接口设计
+
+`TransformedDistribution` 继承自 `Distribution` ，是可通过映射f(x)变化得到的数学分布的基类。其接口包括：
+
+1. 类特征函数
+
+ - `bijector`：无参函数，返回分布的变换方法。
+ - `distribution`：无参函数，返回原始分布。
+ - `is_linear_transformation`：无参函数，返回线性变换标志。
+
+2. 接口函数（以下接口函数的参数与构造函数中 `distribution` 的对应接口的参数相同）。
+
+ - `cdf`：累积分布函数（CDF）。
+ - `log_cdf`：对数累积分布函数。
+ - `survival_function`：生存函数。
+ - `log_survival`：对数生存函数。
+ - `prob`：概率密度函数（PDF）/ 概率质量函数（PMF）。
+ - `log_prob`：对数似然函数。
+ - `sample`：随机取样。
+ - `mean`：无参数。只有当 `Bijector.is_constant_jacobian=true` 时可调用。
+
+### PyNative模式下调用TransformedDistribution实例
+
+`TransformedDistribution` 子类可在 **PyNative** 模式下使用。
+在执行之前，我们需要导入需要的库文件包。
+
+导入相关模块：
+
+```python
+import numpy as np
+import mindspore.nn as nn
+import mindspore.nn.probability.bijector as msb
+import mindspore.nn.probability.distribution as msd
+import mindspore.context as context
+from mindspore import Tensor
+from mindspore import dtype
+context.set_context(mode=context.PYNATIVE_MODE)
+```
+
+构造一个 `TransformedDistribution` 实例，使用 `Normal` 分布作为需要变换的分布类，使用 `Exp` 作为映射变换，可以生成 `LogNormal` 分布。
+
+```python
+normal = msd.Normal(0.0, 1.0, dtype=dtype.float32)
+exp = msb.Exp()
+LogNormal = msd.TransformedDistribution(exp, normal, dtype=dtype.float32, seed=0, name="LogNormal")
+print(LogNormal)
+```
+
+输出为：
+
+```python
+TransformedDistribution<
+ (_bijector): Exp
+
+## 概述
+
+执行主要有三种方式：单算子、普通函数和网络训练模型。
+
+## 执行单算子
+
+执行单个算子，并打印相关结果。
+
+代码样例如下：
+
+```python
+import numpy as np
+import mindspore.nn as nn
+from mindspore import context, Tensor
+
+context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
+
+conv = nn.Conv2d(3, 4, 3, bias_init='zeros')
+input_data = Tensor(np.ones([1, 3, 5, 5]).astype(np.float32))
+output = conv(input_data)
+print(output.asnumpy())
+```
+
+输出如下：
+
+```python
+[[[[ 0.06022915 0.06149777 0.06149777 0.06149777 0.01145121]
+ [ 0.06402162 0.05889071 0.05889071 0.05889071 -0.00933781]
+ [ 0.06402162 0.05889071 0.05889071 0.05889071 -0.00933781]
+ [ 0.06402162 0.05889071 0.05889071 0.05889071 -0.00933781]
+ [ 0.02712326 0.02096302 0.02096302 0.02096302 -0.01119636]]
+
+ [[-0.0258286 -0.03362969 -0.03362969 -0.03362969 -0.00799183]
+ [-0.0513729 -0.06778982 -0.06778982 -0.06778982 -0.03168458]
+ [-0.0513729 -0.06778982 -0.06778982 -0.06778982 -0.03168458]
+ [-0.0513729 -0.06778982 -0.06778982 -0.06778982 -0.03168458]
+ [-0.04186669 -0.07266843 -0.07266843 -0.07266843 -0.04836193]]
+
+ [[-0.00840744 -0.03043237 -0.03043237 -0.03043237 0.00172079]
+ [ 0.00401019 -0.03755453 -0.03755453 -0.03755453 -0.00851137]
+ [ 0.00401019 -0.03755453 -0.03755453 -0.03755453 -0.00851137]
+ [ 0.00401019 -0.03755453 -0.03755453 -0.03755453 -0.00851137]
+ [ 0.00270888 -0.03718876 -0.03718876 -0.03718876 -0.03043662]]
+
+ [[-0.00982172 0.02009856 0.02009856 0.02009856 0.03327979]
+ [ 0.02529106 0.04035065 0.04035065 0.04035065 0.01782833]
+ [ 0.02529106 0.04035065 0.04035065 0.04035065 0.01782833]
+ [ 0.02529106 0.04035065 0.04035065 0.04035065 0.01782833]
+ [ 0.01015155 0.00781826 0.00781826 0.00781826 -0.02884173]]]]
+```
+
+## 执行普通函数
+
+将若干算子组合成一个函数，然后直接通过函数调用的方式执行这些算子，并打印相关结果，如下例所示。
+
+代码样例如下：
+
+```python
+import numpy as np
+from mindspore import context, Tensor
+import mindspore.ops as ops
+
+context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
+
+def tensor_add_func(x, y):
+ z = ops.tensor_add(x, y)
+ z = ops.tensor_add(z, x)
+ return z
+
+x = Tensor(np.ones([3, 3], dtype=np.float32))
+y = Tensor(np.ones([3, 3], dtype=np.float32))
+output = tensor_add_func(x, y)
+print(output.asnumpy())
+```
+
+输出如下：
+
+```python
+[[3. 3. 3.]
+ [3. 3. 3.]
+ [3. 3. 3.]]
+```
+
+## 执行网络模型
+
+MindSpore的Model接口是用于训练和验证的高级接口。可以将有训练或推理功能的layers组合成一个对象，通过调用train、eval、predict接口可以分别实现训练、推理和预测功能。
+
+用户可以根据实际需要传入网络、损失函数和优化器等初始化Model接口，还可以通过配置amp_level实现混合精度，配置metrics实现模型评估。
+
+### 执行训练模型
+
+通过调用Model的train接口可以实现训练。
+
+代码样例如下：
+
+```python
+import os
+
+import mindspore.dataset.vision.c_transforms as CV
+from mindspore.dataset.vision import Inter
+
+import mindspore.dataset as ds
+import mindspore.dataset.transforms.c_transforms as CT
+import mindspore.dataset.vision.c_transforms as CV
+import mindspore.nn as nn
+from mindspore import context
+from mindspore.common import dtype as mstype
+from mindspore.common.initializer import Normal
+from mindspore.common.initializer import TruncatedNormal
+from mindspore.dataset.vision import Inter
+from mindspore.train import Model
+from mindspore.train.callback import LossMonitor
+
+
+def create_dataset(data_path, batch_size=32, repeat_size=1,
+ num_parallel_workers=1):
+ """
+ create dataset for train or test
+ """
+ # define dataset
+ mnist_ds = ds.MnistDataset(data_path)
+
+ resize_height, resize_width = 32, 32
+ rescale = 1.0 / 255.0
+ shift = 0.0
+ rescale_nml = 1 / 0.3081
+ shift_nml = -1 * 0.1307 / 0.3081
+
+ # define map operations
+ resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR) # Bilinear mode
+ rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)
+ rescale_op = CV.Rescale(rescale, shift)
+ hwc2chw_op = CV.HWC2CHW()
+ type_cast_op = CT.TypeCast(mstype.int32)
+
+ # apply map operations on images
+ mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)
+
+ # apply DatasetOps
+ buffer_size = 10000
+ mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size) # 10000 as in LeNet train script
+ mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
+ mnist_ds = mnist_ds.repeat(repeat_size)
+
+ return mnist_ds
+
+
+def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
+ """weight initial for conv layer"""
+ weight = weight_variable()
+ return nn.Conv2d(in_channels, out_channels,
+ kernel_size=kernel_size, stride=stride, padding=padding,
+ weight_init=weight, has_bias=False, pad_mode="valid")
+
+
+def fc_with_initialize(input_channels, out_channels):
+ """weight initial for fc layer"""
+ weight = weight_variable()
+ bias = weight_variable()
+ return nn.Dense(input_channels, out_channels, weight, bias)
+
+
+def weight_variable():
+ """weight initial"""
+ return TruncatedNormal(0.02)
+
+
+class LeNet5(nn.Cell):
+ """
+ Lenet network
+
+ Args:
+ num_class (int): Num classes. Default: 10.
+ num_channel (int): Num channels. Default: 1.
+
+ Returns:
+ Tensor, output tensor
+ Examples:
+ >>> LeNet(num_class=10)
+
+ """
+
+ def __init__(self, num_class=10, num_channel=1):
+ super(LeNet5, self).__init__()
+ self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
+ self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
+ self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
+ self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
+ self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
+ self.relu = nn.ReLU()
+ self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
+ self.flatten = nn.Flatten()
+
+ def construct(self, x):
+ x = self.max_pool2d(self.relu(self.conv1(x)))
+ x = self.max_pool2d(self.relu(self.conv2(x)))
+ x = self.flatten(x)
+ x = self.relu(self.fc1(x))
+ x = self.relu(self.fc2(x))
+ x = self.fc3(x)
+ return x
+
+
+if __name__ == "__main__":
+ context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
+ ds_train = create_dataset(os.path.join("/home/workspace/mindspore_dataset/MNIST_Data/", "train"), 32)
+
+ network = LeNet5(10)
+ net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
+ net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
+ model = Model(network, net_loss, net_opt)
+
+ print("============== Starting Training ==============")
+ model.train(1, ds_train, callbacks=[LossMonitor()], dataset_sink_mode=True)
+```
+
+> 示例中用到的MNIST数据集的获取方法，可以参照[实现一个图片分类应用](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/quick_start/quick_start.html)的下载数据集部分，下同。
+
+输出如下：
+
+```python
+epoch: 1 step: 1, loss is 2.300784
+epoch: 1 step: 2, loss is 2.3076947
+epoch: 1 step: 3, loss is 2.2993166
+...
+epoch: 1 step: 1873, loss is 0.13014838
+epoch: 1 step: 1874, loss is 0.0346688
+epoch: 1 step: 1875, loss is 0.017264696
+```
+
+> 使用PyNative模式调试， 请参考[使用PyNative模式调试](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/debug_in_pynative_mode.html)， 包括单算子、普通函数和网络训练模型的执行。
+
+### 执行推理模型
+
+通过调用Model的train接口可以实现推理。为了方便评估模型的好坏，可以在Model接口初始化的时候设置评估指标Metric。
+
+Metric是用于评估模型好坏的指标。常见的主要有Accuracy、Fbeta、Precision、Recall和TopKCategoricalAccuracy等，通常情况下，一种模型指标无法全面的评估模型的好坏，一般会结合多个指标共同作用对模型进行评估。
+
+常用的内置评估指标：
+
+- `Accuracy`（准确率）：是一个用于评估分类模型的指标。通俗来说，准确率是指我们的模型预测正确的结果所占的比例。 公式：$$Accuracy = （TP+TN）/（TP+TN+FP+FN）$$
+
+- `Precision`（精确率）：在被识别为正类别的样本中，确实为正类别的比例。公式：$$Precision = TP/(TP+FP)$$
+
+- `Recall`（召回率）：在所有正类别样本中，被正确识别为正类别的比例。 公式：$$Recall = TP/(TP+FN)$$
+
+- `Fbeta`（调和均值）：综合考虑precision和recall的调和均值。
+公式：$$F_\beta = (1 + \beta^2) \cdot \frac{precisiont \cdot recall}{(\beta^2 \cdot precision) + recall}$$
+
+- `TopKCategoricalAccuracy`（多分类TopK准确率）：计算TopK分类准确率。
+
+代码样例如下：
+
+```python
+import os
+
+import mindspore.dataset as ds
+import mindspore.dataset.transforms.c_transforms as CT
+import mindspore.dataset.vision.c_transforms as CV
+import mindspore.nn as nn
+from mindspore import context
+from mindspore.common import dtype as mstype
+from mindspore.common.initializer import Normal
+from mindspore.dataset.vision import Inter
+from mindspore.nn.metrics import Accuracy, Precision
+from mindspore.train import Model
+from mindspore.train.serialization import load_checkpoint, load_param_into_net
+
+
+class LeNet5(nn.Cell):
+ """
+ Lenet network
+
+ Args:
+ num_class (int): Num classes. Default: 10.
+ num_channel (int): Num channels. Default: 1.
+
+ Returns:
+ Tensor, output tensor
+ Examples:
+ >>> LeNet(num_class=10)
+
+ """
+
+ def __init__(self, num_class=10, num_channel=1):
+ super(LeNet5, self).__init__()
+ self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
+ self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
+ self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
+ self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
+ self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
+ self.relu = nn.ReLU()
+ self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
+ self.flatten = nn.Flatten()
+
+ def construct(self, x):
+ x = self.max_pool2d(self.relu(self.conv1(x)))
+ x = self.max_pool2d(self.relu(self.conv2(x)))
+ x = self.flatten(x)
+ x = self.relu(self.fc1(x))
+ x = self.relu(self.fc2(x))
+ x = self.fc3(x)
+ return x
+
+
+def create_dataset(data_path, batch_size=32, repeat_size=1,
+ num_parallel_workers=1):
+ """
+ create dataset for train or test
+ """
+ # define dataset
+ mnist_ds = ds.MnistDataset(data_path)
+
+ resize_height, resize_width = 32, 32
+ rescale = 1.0 / 255.0
+ shift = 0.0
+ rescale_nml = 1 / 0.3081
+ shift_nml = -1 * 0.1307 / 0.3081
+
+ # define map operations
+ resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR) # Bilinear mode
+ rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)
+ rescale_op = CV.Rescale(rescale, shift)
+ hwc2chw_op = CV.HWC2CHW()
+ type_cast_op = CT.TypeCast(mstype.int32)
+
+ # apply map operations on images
+ mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)
+
+ # apply DatasetOps
+ buffer_size = 10000
+ mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size) # 10000 as in LeNet train script
+ mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
+ mnist_ds = mnist_ds.repeat(repeat_size)
+
+ return mnist_ds
+
+
+if __name__ == "__main__":
+ context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
+
+ network = LeNet5(10)
+ net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
+ repeat_size = 10
+ net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
+ model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy(), "Precision": Precision()})
+
+ print("============== Starting Testing ==============")
+ param_dict = load_checkpoint("./ckpt/checkpoint_lenet-1_1875.ckpt")
+ load_param_into_net(network, param_dict)
+ ds_eval = create_dataset(os.path.join("/home/workspace/mindspore_dataset/MNIST_Data", "test"), 32, 1)
+ acc = model.eval(ds_eval, dataset_sink_mode=True)
+ print("============== {} ==============".format(acc))
+```
+
+其中，
+`load_checkpoint`：通过该接口加载CheckPoint模型参数文件，返回一个参数字典。
+`checkpoint_lenet-1_1875.ckpt`：保存的CheckPoint模型文件名称。
+`load_param_into_net`：通过该接口把参数加载到网络中。
+
+> `checkpoint_lenet-1_1875.ckpt`文件的保存方法，可以参考[实现一个图片分类应用](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/quick_start/quick_start.html)的训练网络部分。
+
+输出如下：
+
+```python
+============== {'Accuracy': 0.96875, 'Precision': array([0.97782258, 0.99451052, 0.98031496, 0.92723881, 0.98352214,
+ 0.97165533, 0.98726115, 0.9472196 , 0.9394551 , 0.98236515])} ==============
+```
diff --git a/api/source_zh_cn/programming_guide/sampler.md b/docs/programming_guide/source_zh_cn/sampler.md
similarity index 41%
rename from api/source_zh_cn/programming_guide/sampler.md
rename to docs/programming_guide/source_zh_cn/sampler.md
index dc76658852fda5925547c3898657fe64b5a69a0a..25863cb05db87b8a2f97fd389272a4562276f218 100644
--- a/api/source_zh_cn/programming_guide/sampler.md
+++ b/docs/programming_guide/source_zh_cn/sampler.md
@@ -5,7 +5,6 @@
- [采样器](#采样器)
- [概述](#概述)
- [MindSpore采样器](#mindspore采样器)
- - [SequentialSampler](#sequentialsampler)
- [RandomSampler](#randomsampler)
- [WeightedRandomSampler](#weightedrandomsampler)
- [SubsetRandomSampler](#subsetrandomsampler)
@@ -15,11 +14,11 @@
-
+
## 概述
-MindSpore提供了多种用途的采样器，帮助用户对数据集进行不同形式的采样，以满足训练需求，能够解决诸如数据集过大或样本类别分布不均等问题。只需在加载数据集时将采样器对象传入，即可实现数据的采样。
+MindSpore提供了多种用途的采样器（Sampler），帮助用户对数据集进行不同形式的采样，以满足训练需求，能够解决诸如数据集过大或样本类别分布不均等问题。只需在加载数据集时传入采样器对象，即可实现数据的采样。
MindSpore目前提供的采样器类别如下表所示。此外，用户也可以根据需要实现自定义的采样器类。
@@ -34,227 +33,148 @@ MindSpore目前提供的采样器类别如下表所示。此外，用户也可
## MindSpore采样器
-下面以[CIFAR10数据集](https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz)为例，介绍MindSpore采样器使用方法。
-
-### SequentialSampler
-
-从指定的索引位置开始顺序采样指定数目的数据。
-
-```python
-# 通过SequentialSampler定义一个顺序采样器，并作用于数据集
-
-import mindspore.dataset as ds
-
-# CIFAR10数据集路径
-DATA_DIR = "Cifar10Data/"
-
-# 1. 定义一个顺序采样器SequentialSampler，按照读取顺序获取5个样本数据
-sampler = ds.SequentialSampler(num_samples=5)
-dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-
-# 启动数据管道，输出5个样本数据
-for data in dataset1.create_dict_iterator():
- print("Image shape:", data['image'].shape, ", Label:", data['label'])
-
-print("")
-
-# 2. 定义一个顺序采样器SequentialSampler，跳过前2个数据，继续按照读取顺序获取5个样本数据
-sampler = ds.SequentialSampler(start_index=2, num_samples=5)
-dataset2 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-
-# 启动数据管道，输出5个样本数据
-for data in dataset2.create_dict_iterator():
- print("Image shape:", data['image'].shape, ", Label:", data['label'])
-
-print("")
-
-# 3. 同类用法，指定数据集中的num_samples参数为5，shuffle参数为False，同样可以达到1的效果
-dataset3 = ds.Cifar10Dataset(DATA_DIR, num_samples=5, shuffle=False)
-
-# 启动数据管道，输出5个样本数据
-for data in dataset3.create_dict_iterator():
- print("Image shape:", data['image'].shape, ", Label:", data['label'])
-```
-
-```
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 2
-Image shape: (32, 32, 3) , Label: 3
-Image shape: (32, 32, 3) , Label: 4
-
-Image shape: (32, 32, 3) , Label: 2
-Image shape: (32, 32, 3) , Label: 3
-Image shape: (32, 32, 3) , Label: 4
-Image shape: (32, 32, 3) , Label: 5
-Image shape: (32, 32, 3) , Label: 6
-
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 2
-Image shape: (32, 32, 3) , Label: 3
-Image shape: (32, 32, 3) , Label: 4
+下面以CIFAR-10数据集为例，介绍几种常用MindSpore采样器的使用方法。下载[CIFAR-10数据集](https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz)并解压，目录结构如下。
+
+```text
+└─cifar-10-batches-bin
+ ├── batches.meta.txt
+ ├── data_batch_1.bin
+ ├── data_batch_2.bin
+ ├── data_batch_3.bin
+ ├── data_batch_4.bin
+ ├── data_batch_5.bin
+ ├── readme.html
+ └── test_batch.bin
```
### RandomSampler
从索引序列中随机采样指定数目的数据。
-```python
-# 通过RandomSampler定义一个随机采样器，并作用于数据集
+下面的样例使用随机采样器分别从CIFAR-10数据集中有放回和无放回地随机采样5个数据，并展示已加载数据的形状和标签。
+```python
import mindspore.dataset as ds
-# 设置全局随机种子，确保RandomSampler的行为可预测
ds.config.set_seed(0)
-# CIFAR数据集路径
-DATA_DIR = "Cifar10Data/"
+DATA_DIR = "cifar-10-batches-bin/"
-# 1. 定义一个随机采样器SequentialSampler，随机获取5个样本数据
sampler = ds.RandomSampler(num_samples=5)
dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 启动数据管道，输出5个样本数据
for data in dataset1.create_dict_iterator():
print("Image shape:", data['image'].shape, ", Label:", data['label'])
-print("")
+print("------------")
-# 2. 定义一个随机采样器RandomSampler，replacement=True意味着有放回抽样
sampler = ds.RandomSampler(replacement=True, num_samples=5)
dataset2 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 启动数据管道，输出5个样本数据
for data in dataset2.create_dict_iterator():
print("Image shape:", data['image'].shape, ", Label:", data['label'])
-
-print("")
-
-# 3. 同类用法，指定数据集中的num_samples参数为5，shuffle参数为True，同样可以达到2的效果
-dataset3 = ds.Cifar10Dataset(DATA_DIR, num_samples=5, shuffle=True)
-
-# 启动数据管道，输出5个样本数据
-for data in dataset3.create_dict_iterator():
- print("Image shape:", data['image'].shape, ", Label:", data['label'])
```
-```
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 2
-Image shape: (32, 32, 3) , Label: 6
-Image shape: (32, 32, 3) , Label: 4
-Image shape: (32, 32, 3) , Label: 6
+输出结果如下：
-Image shape: (32, 32, 3) , Label: 8
-Image shape: (32, 32, 3) , Label: 8
+```text
Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 2
+Image shape: (32, 32, 3) , Label: 6
Image shape: (32, 32, 3) , Label: 7
-
-Image shape: (32, 32, 3) , Label: 8
-Image shape: (32, 32, 3) , Label: 8
+Image shape: (32, 32, 3) , Label: 0
+Image shape: (32, 32, 3) , Label: 4
+------------
+Image shape: (32, 32, 3) , Label: 4
+Image shape: (32, 32, 3) , Label: 6
+Image shape: (32, 32, 3) , Label: 9
Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 2
-Image shape: (32, 32, 3) , Label: 7
+Image shape: (32, 32, 3) , Label: 5
```
### WeightedRandomSampler
指定每种类别的采样概率，按照概率在各类别中随机采样指定数目的数据。
-```python
-# 通过WeightedRandomSampler定义一个带权重的随机采样器，并作用于数据集
+下面的样例使用带权随机采样器从CIFAR-10数据集的10个类别中按概率获取6个样本，并展示已读取数据的形状和标签。
+```python
import mindspore.dataset as ds
-# 设置全局随机种子，确保WeightedRandomSampler的行为可预测
ds.config.set_seed(1)
-# CIFAR数据集路径
-DATA_DIR = "Cifar10Data/"
+DATA_DIR = "cifar-10-batches-bin/"
-# 定义一个带权重的随机采样器WeightedRandomSampler
-# weights代表CIFAR10中10类数据的采样概率，num_samples表示随机获取6个样本数据
-# replacement参数与RandomSampler中一致
weights = [1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
sampler = ds.WeightedRandomSampler(weights, num_samples=6)
-dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
+dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 启动数据管道，输出6个样本数据
-for data in dataset1.create_dict_iterator():
+for data in dataset.create_dict_iterator():
print("Image shape:", data['image'].shape, ", Label:", data['label'])
```
-```
-Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 1
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 0
+输出结果如下：
+
+```text
+Image shape: (32, 32, 3) , Label: 9
+Image shape: (32, 32, 3) , Label: 9
+Image shape: (32, 32, 3) , Label: 6
+Image shape: (32, 32, 3) , Label: 9
+Image shape: (32, 32, 3) , Label: 6
+Image shape: (32, 32, 3) , Label: 6
```
### SubsetRandomSampler
从指定索引子序列中随机采样指定数目的数据。
-```python
-# 通过SubsetRandomSampler定义一个子集随机采样器，并作用于数据集
+下面的样例使用子序列随机采样器从CIFAR-10数据集的指定子序列中抽样3个样本，并展示已读取数据的形状和标签。
+```python
import mindspore.dataset as ds
-# 设置全局随机种子，确保SubsetRandomSampler的行为可预测
ds.config.set_seed(2)
-# CIFAR数据集路径
-DATA_DIR = "Cifar10Data/"
+DATA_DIR = "cifar-10-batches-bin/"
-# 定义一个带采样集合的随机采样器SubsetRandomSampler
-# indice代表可采样的集合，num_samples表示获取3个样本数据，即从可采样集合中(0~5)随机获取3个值，作为下标访问数据集的数据
indices = [0, 1, 2, 3, 4, 5]
sampler = ds.SubsetRandomSampler(indices, num_samples=3)
-dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
+dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 启动数据管道，输出3个样本数据
-for data in dataset1.create_dict_iterator():
+for data in dataset.create_dict_iterator():
print("Image shape:", data['image'].shape, ", Label:", data['label'])
```
-```
-Image shape: (32, 32, 3) , Label: 5
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 3
+输出结果如下：
+
+```text
+Image shape: (32, 32, 3) , Label: 1
+Image shape: (32, 32, 3) , Label: 6
+Image shape: (32, 32, 3) , Label: 4
```
### PKSampler
在指定的数据集类别P中，每种类别各采样K条数据。
-```python
-# 通过PKSampler定义一个针对各个类别随机采样器，并作用于数据集
+下面的样例使用PK采样器从CIFAR-10数据集中每种类别抽样2个样本，最多20个样本，并展示已读取数据的形状和标签。
+```python
import mindspore.dataset as ds
-# 设置全局随机种子，确保PKSampler的shuffle参数行为可预测
ds.config.set_seed(3)
-# CIFAR数据集路径
-DATA_DIR = "Cifar10Data/"
+DATA_DIR = "cifar-10-batches-bin/"
-# 定义一个针对类别采样的随机采样器PKSampler
-# num_val代表从每个类别采样K个样本，class_column代表针对特定的数据列采样（一般是label）
-# num_samples代表输出的样本数，设置num_samples = num_val*class_nums，确保每个类别平均采样
-# shuffle代表样本是否需要被混洗
sampler = ds.PKSampler(num_val=2, class_column='label', num_samples=20)
-dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
+dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)
-# 启动数据管道，输出20个样本数据
-for data in dataset1.create_dict_iterator():
+for data in dataset.create_dict_iterator():
print("Image shape:", data['image'].shape, ", Label:", data['label'])
```
-```
+输出结果如下：
+
+```text
Image shape: (32, 32, 3) , Label: 0
Image shape: (32, 32, 3) , Label: 0
Image shape: (32, 32, 3) , Label: 1
@@ -281,70 +201,57 @@ Image shape: (32, 32, 3) , Label: 9
在分布式训练中，对数据集分片进行采样。
-```python
-# 通过DistributedSampler定义一个将数据集进行分片操作，并获取某个分片进行采样的采样器，并作用于数据集
+下面的样例使用分布式采样器将构建的数据集分为3片，在每个分片中采样3个数据样本，并展示已读取的数据。
+```python
import numpy as np
import mindspore.dataset as ds
-# 构建一个list
data_source = [0, 1, 2, 3, 4, 5, 6, 7, 8]
-# 定义一个采样器DistributedSampler
-# num_shards代表将CIFAR数据集拆分成n个分片
-# shard_id代表获取第m个分片
-# num_samples代表获取该分片的10个样本
-# shuffle代表样本是否需要被混洗
sampler = ds.DistributedSampler(num_shards=3, shard_id=0, shuffle=False, num_samples=3)
-
-# 从list中构建数据管道
dataset = ds.NumpySlicesDataset(data_source, column_names=["data"], sampler=sampler)
-# 经过DistributedSampler分片后，数据集的内容为
-# shard_id 0: 0, 3, 6
-# shard_id 1: 1, 4, 7
-# shard_id 2: 2, 5, 8
-# 因此第0个分片拥有数据为0, 3, 6
for data in dataset.create_dict_iterator():
print(data)
```
-```
-{'data': array(0, dtype=int64)}
-{'data': array(3, dtype=int64)}
-{'data': array(6, dtype=int64)}
+输出结果如下：
+
+```text
+{'data': Tensor(shape=[], dtype=Int64, value= 0)}
+{'data': Tensor(shape=[], dtype=Int64, value= 3)}
+{'data': Tensor(shape=[], dtype=Int64, value= 6)}
```
## 自定义采样器
-用户可以继承Sampler基类，通过实现`__iter__`方法来自定义采样器的采样方式。
+用户可以继承`Sampler`基类，通过实现`__iter__`方法来自定义采样器的采样方式。
-```python
-# 继承Sampler基类，重载__iter__成为新的采样器
+下面的样例定义了一个从下标0至下标9间隔为2采样的采样器，将其作用于CIFAR-10数据集，并展示已读取数据的形状和标签。
+```python
import mindspore.dataset as ds
class MySampler(ds.Sampler):
def __iter__(self):
- # 采样器的行为是，从下标0开始到下标9，以2为间隔采样
for i in range(0, 10, 2):
yield i
-# CIFAR数据集路径
-DATA_DIR = "Cifar10Data/"
+DATA_DIR = "cifar-10-batches-bin/"
-# 将自定义构建的采样器传入到sampler参数
-dataset1 = ds.Cifar10Dataset(DATA_DIR, sampler=MySampler())
+dataset = ds.Cifar10Dataset(DATA_DIR, sampler=MySampler())
-# 启动数据管道，输出5个样本数据
-for data in dataset1.create_dict_iterator():
+for data in dataset.create_dict_iterator():
print("Image shape:", data['image'].shape, ", Label:", data['label'])
```
-```
-Image shape: (32, 32, 3) , Label: 0
-Image shape: (32, 32, 3) , Label: 2
-Image shape: (32, 32, 3) , Label: 4
+输出结果如下：
+
+```text
Image shape: (32, 32, 3) , Label: 6
+Image shape: (32, 32, 3) , Label: 9
+Image shape: (32, 32, 3) , Label: 1
+Image shape: (32, 32, 3) , Label: 2
Image shape: (32, 32, 3) , Label: 8
```
diff --git a/docs/programming_guide/source_zh_cn/security_and_privacy.md b/docs/programming_guide/source_zh_cn/security_and_privacy.md
new file mode 100644
index 0000000000000000000000000000000000000000..023d8993c8b01a3323a8abbbd1473c6431e4684f
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/security_and_privacy.md
@@ -0,0 +1,64 @@
+# AI安全与隐私保护
+
+
+
+- [AI安全与隐私保护](#ai安全与隐私保护)
+ - [概述](#概述)
+ - [对抗鲁棒性](#对抗鲁棒性)
+ - [Attack](#attack)
+ - [Defense](#defense)
+ - [Detector](#detector)
+ - [模型安全测试](#模型安全测试)
+ - [Fuzzer](#fuzzer)
+ - [差分隐私训练](#差分隐私训练)
+ - [DPModel](#dpmodel)
+ - [隐私泄露风险评估](#隐私泄露风险评估)
+ - [MembershipInference](#membershipinference)
+
+
+
+
+
+## 概述
+
+本篇主要介绍AI安全与隐私保护。AI作为一种通用技术，在带来巨大机遇和效益的同时也面临着新的安全与隐私保护的挑战。MindArmour是MindSpore的一个子项目，为MindSpore提供安全与隐私保护能力，主要包括对抗鲁棒性、模型安全测试、差分隐私训练、隐私泄露风险评估等技术。
+
+## 对抗鲁棒性
+
+### Attack
+
+`Attack`基类定义了对抗样本生成的使用接口，其子类实现了各种具体的生成算法，支持安全工作人员快速高效地生成对抗样本，用于攻击AI模型，以评估模型的鲁棒性。
+
+### Defense
+
+`Defense`基类定义了对抗训练的使用接口，其子类实现了各种具体的对抗训练算法，增强模型的对抗鲁棒性。
+
+### Detector
+
+`Detector`基类定义了对抗样本检测的使用借口，其子类实现了各种具体的检测算法，增强模型的对抗鲁棒性。
+
+详细内容，请参考[对抗鲁棒性官网教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/improve_model_security_nad.html)。
+
+## 模型安全测试
+
+### Fuzzer
+
+`Fuzzer`类基于神经元覆盖率增益控制fuzzing流程，采用自然扰动和对抗样本生成方法作为变异策略，激活更多的神经元，从而探索不同类型的模型输出结果、错误行为，指导用户增强模型鲁棒性。
+
+详细内容，请参考[模型安全测试官网教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/test_model_security_fuzzing.html)。
+
+## 差分隐私训练
+
+### DPModel
+
+`DPModel`继承了`mindspore.Model`，提供了差分隐私训练的入口函数。
+
+详细内容，请参考[差分隐私官网教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/protect_user_privacy_with_differential_privacy.html)。
+
+## 隐私泄露风险评估
+
+### MembershipInference
+
+`MembershipInference`类提供了一种模型逆向分析方法，能够基于模型对样本的预测信息，推测某个样本是否在模型的训练集中，以此评估模型的隐私泄露风险。
+
+详细内容，请参考[隐私泄露风险评估官方教程](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/test_model_security_membership_inference.html)。
diff --git a/api/source_zh_cn/programming_guide/tensor.md b/docs/programming_guide/source_zh_cn/tensor.md
similarity index 59%
rename from api/source_zh_cn/programming_guide/tensor.md
rename to docs/programming_guide/source_zh_cn/tensor.md
index 3959362bb808dba14c31328977e11075d25c773c..ad310a0f89c38d74eccea4cda56d24c97f571902 100644
--- a/api/source_zh_cn/programming_guide/tensor.md
+++ b/docs/programming_guide/source_zh_cn/tensor.md
@@ -1,8 +1,8 @@
-# 张量
+# Tensor
-- [张量](#张量)
+- [Tensor](#tensor)
- [概述](#概述)
- [张量构造](#张量构造)
- [张量的属性和方法](#张量的属性和方法)
@@ -11,28 +11,25 @@
-
+
## 概述
-张量是MindSpore网络运算中的基本数据结构，即为多维数组。张量里的数据分为不同的类型，
-支持的类型有`int8`、`int16`、`int32`、`int64`、`uint8`、`uint16`、`uint32`、`uint64`、`float16`、`float32`、`float64`、`bool_`，
-与NumPy里的数据类型一一对应。
+张量（Tensor）是MindSpore网络运算中的基本数据结构。张量中的数据类型可参考[dtype](https://www.mindspore.cn/doc/programming_guide/zh-CN/r1.0/dtype.html)。
不同维度的张量分别表示不同的数据，0维张量表示标量，1维张量表示向量，2维张量表示矩阵，3维张量可以表示彩色图像的RGB三通道等等。
-> 本文档中的所有示例，都是在PyNative模式下运行的，暂不支持CPU。
-
+> 本文中的所有示例，支持在PyNative模式下运行，暂不支持CPU。
+
## 张量构造
-构造张量时支持传入`Tensor`、`float`、`int`、`bool`、`tuple`、`list`和`NumPy.array`。
+构造张量时，支持传入`Tensor`、`float`、`int`、`bool`、`tuple`、`list`和`NumPy.array`类型。
-`Tensor`作为初始值可指定dtype，如果没有指定dtype，`int`、`float`、`bool`分别对应`int32`、`float32`、`bool_`，
-`tuple`和`list`生成的1维`Tensor`数据类型与`tuple`和`list`里存放数据的类型相对应。
+`Tensor`作为初始值时，可指定dtype，如果没有指定dtype，`int`、`float`、`bool`分别对应`int32`、`float32`、`bool_`，`tuple`和`list`生成的1维`Tensor`数据类型与`tuple`和`list`里存放数据的类型相对应。
代码样例如下：
-```
+```python
import numpy as np
from mindspore import Tensor
from mindspore.common import dtype as mstype
@@ -49,7 +46,7 @@ print(x, "\n\n", y, "\n\n", z, "\n\n", m, "\n\n", n, "\n\n", p)
输出如下：
-```
+```text
[[1 2]
[3 4]]
@@ -63,17 +60,19 @@ True
[4. 5. 6.]
```
-
+
## 张量的属性和方法
+
### 属性
张量的属性包括形状（shape）和数据类型（dtype）。
+
- 形状：`Tensor`的shape，是一个tuple。
-- 数据类型：`Tensor`的的dtype，是MindSpore的一个数据类型。
+- 数据类型：`Tensor`的dtype，是MindSpore的一个数据类型。
代码样例如下：
-```
+```python
import numpy as np
from mindspore import Tensor
from mindspore.common import dtype as mstype
@@ -87,20 +86,21 @@ print(x_shape, x_dtype)
输出如下：
-```
+```text
(2, 2) Int32
```
-
+
### 方法
-张量的方法包括`all`、`any`和`asnumpy`。
-- `all(axis, keep_dims)`：在指定维度上通过`and`操作进行归约，axis代表归约维度，keep_dims表示是否保留归约后的维度。
-- `any(axis, keep_dims)`：在指定维度上通过`or`操作进行归约，axis代表归约维度，keep_dims表示是否保留归约后的维度。
+张量的方法包括`all`、`any`和`asnumpy`，`all`和`any`方法目前只支持Ascend。
+
+- `all(axis, keep_dims)`：在指定维度上通过`and`操作进行归约，`axis`代表归约维度，`keep_dims`表示是否保留归约后的维度。
+- `any(axis, keep_dims)`：在指定维度上通过`or`操作进行归约，参数含义同`all`。
- `asnumpy()`：将`Tensor`转换为NumPy的array。
代码样例如下：
-```
+```python
import numpy as np
from mindspore import Tensor
from mindspore.common import dtype as mstype
@@ -115,7 +115,7 @@ print(x_all, "\n\n", x_any, "\n\n", x_array)
输出如下：
-```
+```text
False
True
diff --git a/api/source_zh_cn/programming_guide/tokenizer.md b/docs/programming_guide/source_zh_cn/tokenizer.md
similarity index 36%
rename from api/source_zh_cn/programming_guide/tokenizer.md
rename to docs/programming_guide/source_zh_cn/tokenizer.md
index 8ac94e6a54d453785728c66681b78d410f1288c0..81d9cc23d8fbc296c1667e4cc893186b01688886 100644
--- a/api/source_zh_cn/programming_guide/tokenizer.md
+++ b/docs/programming_guide/source_zh_cn/tokenizer.md
@@ -1,20 +1,26 @@
# 分词器
-
+
- [分词器](#分词器)
- [概述](#概述)
- [MindSpore分词器](#mindspore分词器)
+ - [BertTokenizer](#BertTokenizer)
+ - [JiebaTokenizer](#JiebaTokenizer)
+ - [SentencePieceTokenizer](#SentencePieceTokenizer)
+ - [UnicodeCharTokenizer](#UnicodeCharTokenizer)
+ - [WhitespaceTokenizer](#WhitespaceTokenizer)
+ - [WordpieceTokenizer](#WordpieceTokenizer)
-
+
## 概述
分词就是将连续的字序列按照一定的规范重新组合成词序列的过程，合理的进行分词有助于语义的理解。
-MindSpore提供了多种用途的分词器，能够帮助用户高性能地处理文本，用户可以构建自己的字典，使用适当的标记器将句子拆分为不同的标记，并通过查找操作获取字典中标记的索引。
+MindSpore提供了多种用途的分词器（Tokenizer），能够帮助用户高性能地处理文本，用户可以构建自己的字典，使用适当的标记器将句子拆分为不同的标记，并通过查找操作获取字典中标记的索引。
MindSpore目前提供的分词器如下表所示。此外，用户也可以根据需要实现自定义的分词器。
@@ -30,109 +36,51 @@ MindSpore目前提供的分词器如下表所示。此外，用户也可以根
| WhitespaceTokenizer | 根据空格符对标量文本数据进行分词。 |
| WordpieceTokenizer | 根据单词集对标量文本数据进行分词。 |
-更多分词器的详细说明，可以参见[API文档](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.dataset.text.html)。
+更多分词器的详细说明，可以参见[API文档](https://www.mindspore.cn/doc/api_python/zh-CN/r1.0/mindspore/mindspore.dataset.text.html)。
## MindSpore分词器
-### BasicTokenizer
-
-`BasicTokenizer`是通过大小写折叠、编码统一、去除重音符，按照正则匹配模式来分词的。
-
-```python
-import mindspore.dataset as ds
-import mindspore.dataset.text as text
-
-# 构建输入的数据列表
-input_list = ["Welcome to Beijing北京欢迎您", "長風破浪會有時，直掛雲帆濟滄海","😀嘿嘿😃哈哈😄大笑😁嘻嘻",
- "明朝（1368—1644年）和清朝（1644—1911年），是中国封建王朝史上最后两个朝代",
- "明代（1368-1644）と清代（1644-1911）は、中国の封建王朝の歴史における最後の2つの王朝でした",
- "명나라 (1368-1644)와 청나라 (1644-1911)는 중국 봉건 왕조의 역사에서 마지막 두 왕조였다"]
-
-dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-
-print("------------------------before tokenize----------------------------")
-
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
- print(text.to_str(data['text']))
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
-# 输出分词之后的数据
-# BasicTokenizer为分词的函数
-basic_tokenizer = text.BasicTokenizer()
-
-dataset = dataset.map(operations=basic_tokenizer)
-
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text'])
- print(token)
-```
-
-```
-------------------------before tokenize----------------------------
-Welcome to Beijing北京欢迎您
-長風破浪會有時，直掛雲帆濟滄海
-😀嘿嘿😃哈哈😄大笑😁嘻嘻
-明朝（1368—1644年）和清朝（1644—1911年），是中国封建王朝史上最后两个朝代
-明代（1368-1644）と清代（1644-1911）は、中国の封建王朝の歴史における最後の2つの王朝でした
-명나라 (1368-1644)와 청나라 (1644-1911)는 중국 봉건 왕조의 역사에서 마지막 두 왕조였다
-------------------------after tokenize-----------------------------
-['Welcome' 'to' 'Beijing' '北' '京' '欢' '迎' '您']
-['長' '風' '破' '浪' '會' '有' '時' '，' '直' '掛' '雲' '帆' '濟' '滄' '海']
-['😀' '嘿' '嘿' '😃' '哈' '哈' '😄' '大' '笑' '😁' '嘻' '嘻']
-['明' '朝' '（' '1368' '—' '1644' '年' '）' '和' '清' '朝' '（' '1644' '—' '1911' '年' '）' '，' '是' '中' '国' '封' '建' '王' '朝' '史' '上' '最' '后' '两' '个' '朝' '代']
-['明' '代' '（' '1368' '-' '1644' '）' 'と' '清' '代' '（' '1644' '-' '1911' '）' 'は' '、' '中' '国' 'の' '封' '建' '王' '朝' 'の' '歴' '史' 'における' '最' '後' 'の2つの' '王' '朝' 'でした']
-['명나라' '(' '1368' '-' '1644' ')' '와' '청나라' '(' '1644' '-' '1911' ')' '는' '중국' '봉건' '왕조의' '역사에서' '마지막' '두' '왕조였다']
-```
+下面介绍几种常用分词器的使用方法。
### BertTokenizer
`BertTokenizer`是通过调用`BasicTokenizer`和`WordpieceTokenizer`来进行分词的。
+下面的样例首先构建了一个文本数据集和字符串列表，然后通过`BertTokenizer`对数据集进行分词，并展示了分词前后的文本结果。
+
```python
import mindspore.dataset as ds
import mindspore.dataset.text as text
-# 构建输入的数据列表
input_list = ["床前明月光", "疑是地上霜", "举头望明月", "低头思故乡", "I am making small mistakes during working hours",
"😀嘿嘿😃哈哈😄大笑😁嘻嘻", "繁體字"]
-
dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-print("------------------------before tokenize----------------------------")
+print("------------------------before tokenization----------------------------")
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
+for data in dataset.create_dict_iterator(output_numpy=True):
print(text.to_str(data['text']))
-# 字符串列表，其中每个元素都是字符串类型的单词。
vocab_list = [
"床", "前", "明", "月", "光", "疑", "是", "地", "上", "霜", "举", "头", "望", "低", "思", "故", "乡",
"繁", "體", "字", "嘿", "哈", "大", "笑", "嘻", "i", "am", "mak", "make", "small", "mistake",
"##s", "during", "work", "##ing", "hour", "😀", "😃", "😄", "😁", "+", "/", "-", "=", "12",
"28", "40", "16", " ", "I", "[CLS]", "[SEP]", "[UNK]", "[PAD]", "[MASK]", "[unused1]", "[unused10]"]
-# 从单词列表中构建一个vocab对象
vocab = text.Vocab.from_list(vocab_list)
-
-# 输出分词之后的数据
-# BertTokenizer为分词的函数
tokenizer_op = text.BertTokenizer(vocab=vocab)
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
dataset = dataset.map(operations=tokenizer_op)
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text'])
- print(token)
-```
+print("------------------------after tokenization-----------------------------")
+for i in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+ print(text.to_str(i['text']))
```
-------------------------before tokenize----------------------------
+
+输出结果如下：
+
+```text
+------------------------before tokenization----------------------------
床前明月光
疑是地上霜
举头望明月
@@ -140,12 +88,13 @@ for i in dataset.create_dict_iterator(num_epochs=1):
I am making small mistakes during working hours
😀嘿嘿😃哈哈😄大笑😁嘻嘻
繁體字
-------------------------after tokenize-----------------------------
+------------------------after tokenization-----------------------------
['床' '前' '明' '月' '光']
['疑' '是' '地' '上' '霜']
['举' '头' '望' '明' '月']
['低' '头' '思' '故' '乡']
-['i' 'am' 'mak' '##ing' 'small' 'mistake' '##s' 'during' 'work' '##ing' 'hour' '##s']
+['I' 'am' 'mak' '##ing' 'small' 'mistake' '##s' 'during' 'work' '##ing'
+ 'hour' '##s']
['😀' '嘿' '嘿' '😃' '哈' '哈' '😄' '大' '笑' '😁' '嘻' '嘻']
['繁' '體' '字']
```
@@ -154,123 +103,78 @@ I am making small mistakes during working hours
`JiebaTokenizer`是基于jieba的中文分词。
+下面的样例首先构建了一个文本数据集，然后使用HMM与MP字典文件创建`JiebaTokenizer`对象，并对数据集进行分词，最后展示了分词前后的文本结果。
+
```python
import mindspore.dataset as ds
import mindspore.dataset.text as text
-# 构建输入的数据列表
-input_list = ["床前明月光", "疑是地上霜", "举头望明月", "低头思故乡", "I am making small mistakes during working hours",
- "😀嘿嘿😃哈哈😄大笑😁嘻嘻", "繁體字"]
-
-# 字典文件由HMMSegment算法和MPSegment算法使用，该字典可在cppjieba的官方网站上获得。
-HMM_FILE = "hmm_model.utf8"
-MP_FILE = "jieba.dict.utf8"
-
+input_list = ["今天天气太好了我们一起去外面玩吧"]
dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-print("------------------------before tokenize----------------------------")
+print("------------------------before tokenization----------------------------")
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
+for data in dataset.create_dict_iterator(output_numpy=True):
print(text.to_str(data['text']))
-tokenizer_op = text.JiebaTokenizer(HMM_FILE, MP_FILE)
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
+# files from open source repository https://github.com/yanyiwu/cppjieba/tree/master/dict
+HMM_FILE = "hmm_model.utf8"
+MP_FILE = "jieba.dict.utf8"
+jieba_op = text.JiebaTokenizer(HMM_FILE, MP_FILE)
+dataset = dataset.map(operations=jieba_op, input_columns=["text"], num_parallel_workers=1)
-dataset = dataset.map(input_columns=["text"], operations=jieba_op, num_parallel_workers=1)
+print("------------------------after tokenization-----------------------------")
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text'])
- print(token)
+for i in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+ print(text.to_str(i['text']))
```
-```
-------------------------before tokenize----------------------------
+输出结果如下：
+
+```text
+------------------------before tokenization----------------------------
今天天气太好了我们一起去外面玩吧
-------------------------after tokenize-----------------------------
+------------------------after tokenization-----------------------------
['今天天气' '太好了' '我们' '一起' '去' '外面' '玩吧']
```
-### RegexTokenizer
-
-`RegexTokenizer`是通正则表达式匹配模式来进行分词的。
-
-```python
-import mindspore.dataset as ds
-import mindspore.dataset.text as text
-
-# 构建输入的数据列表
-input_list = ["Welcome to Shenzhen!"]
-
-# 原始字符串将由匹配的元素分隔。
-delim_pattern = "\\s+"
-
-dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-
-print("------------------------before tokenize----------------------------")
-
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
- print(text.to_str(data['text']))
-
-tokenizer_op = text.RegexTokenizer(delim_pattern)
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
-dataset = dataset.map(operations=tokenizer_op)
-
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text']).tolist()
- print(token)
-```
-
-```
-------------------------before tokenize----------------------------
-Welcome to Shenzhen!
-------------------------after tokenize-----------------------------
-['Welcome', 'to', 'Shenzhen!']
-```
-
### SentencePieceTokenizer
-`SentencePieceTokenizer`是基于SentencePiece这个开源的自然语言处理工具包。
+`SentencePieceTokenizer`是基于[SentencePiece](https://github.com/google/sentencepiece)这个开源的自然语言处理工具包。
+
+下面的样例首先构建了一个文本数据集，然后从`vocab_file`文件中构建一个`vocab`对象，再通过`SentencePieceTokenizer`对数据集进行分词，并展示了分词前后的文本结果。
```python
import mindspore.dataset as ds
import mindspore.dataset.text as text
+from mindspore.dataset.text import SentencePieceModel, SPieceTokenizerOutType
-# 构建输入的数据列表
input_list = ["I saw a girl with a telescope."]
-
dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-print("------------------------before tokenize----------------------------")
+print("------------------------before tokenization----------------------------")
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
+for data in dataset.create_dict_iterator(output_numpy=True):
print(text.to_str(data['text']))
-# 从文件数据中构建一个vocab对象
-vocab = text.SentencePieceVocab.from_file([VOCAB_FILE], 5000, 0.9995, SentencePieceModel.UNIGRAM, {})
+# file from MindSpore repository https://gitee.com/mindspore/mindspore/blob/r1.0/tests/ut/data/dataset/test_sentencepiece/botchan.txt
+vocab_file = "botchan.txt"
+vocab = text.SentencePieceVocab.from_file([vocab_file], 5000, 0.9995, SentencePieceModel.UNIGRAM, {})
tokenizer_op = text.SentencePieceTokenizer(vocab, out_type=SPieceTokenizerOutType.STRING)
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
dataset = dataset.map(operations=tokenizer_op)
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text'])
- print(token)
-```
+print("------------------------after tokenization-----------------------------")
+for i in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+ print(text.to_str(i['text']))
```
-------------------------before tokenize----------------------------
+
+输出结果如下：
+
+```text
+------------------------before tokenization----------------------------
I saw a girl with a telescope.
-------------------------after tokenize-----------------------------
+------------------------after tokenization-----------------------------
['▁I' '▁sa' 'w' '▁a' '▁girl' '▁with' '▁a' '▁te' 'les' 'co' 'pe' '.']
```
@@ -278,124 +182,77 @@ I saw a girl with a telescope.
`UnicodeCharTokenizer`是根据Unicode字符集来分词的。
+下面的样例首先构建了一个文本数据集，然后通过`UnicodeCharTokenizer`对数据集进行分词，并展示了分词前后的文本结果。
+
```python
import mindspore.dataset as ds
import mindspore.dataset.text as text
-# 构建输入的数据列表
input_list = ["Welcome to Beijing!", "北京欢迎您！", "我喜欢English!"]
-
dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-print("------------------------before tokenize----------------------------")
+print("------------------------before tokenization----------------------------")
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
+for data in dataset.create_dict_iterator(output_numpy=True):
print(text.to_str(data['text']))
tokenizer_op = text.UnicodeCharTokenizer()
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
dataset = dataset.map(operations=tokenizer_op)
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text']).tolist()
- print(token)
-```
+print("------------------------after tokenization-----------------------------")
+for i in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+ print(text.to_str(i['text']).tolist())
```
-------------------------before tokenize----------------------------
+
+输出结果如下：
+
+```text
+------------------------before tokenization----------------------------
Welcome to Beijing!
北京欢迎您！
我喜欢English!
-------------------------after tokenize-----------------------------
+------------------------after tokenization-----------------------------
['W', 'e', 'l', 'c', 'o', 'm', 'e', ' ', 't', 'o', ' ', 'B', 'e', 'i', 'j', 'i', 'n', 'g', '!']
['北', '京', '欢', '迎', '您', '！']
['我', '喜', '欢', 'E', 'n', 'g', 'l', 'i', 's', 'h', '!']
```
-### UnicodeScriptTokenizer
-
-`UnicodeScriptTokenizer`是根据不同的Unicode的边界来进行分词的。
-
-```python
-import mindspore.dataset as ds
-import mindspore.dataset.text as text
-
-# 构建输入的数据列表
-input_list = ["Welcome to Beijing!", "北京欢迎您！", "我喜欢English!"]
-
-dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-
-print("------------------------before tokenize----------------------------")
-
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
- print(text.to_str(data['text']))
-
-tokenizer_op = text.UnicodeScriptTokenizer()
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
-dataset = dataset.map(operations=tokenizer_op)
-
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text']).tolist()
- print(token)
-```
-
-```
-------------------------before tokenize----------------------------
-Welcome to Beijing!
-北京欢迎您！
-我喜欢English!
-------------------------after tokenize-----------------------------
-['Welcome', 'to', 'Beijing', '!']
-['北京欢迎您', '！']
-['我喜欢', 'English', '!']
-```
-
### WhitespaceTokenizer
`WhitespaceTokenizer`是根据空格来进行分词的。
+下面的样例首先构建了一个文本数据集，然后通过`WhitespaceTokenizer`对数据集进行分词，并展示了分词前后的文本结果。
+
```python
import mindspore.dataset as ds
import mindspore.dataset.text as text
-# 构建输入的数据列表
input_list = ["Welcome to Beijing!", "北京欢迎您！", "我喜欢English!"]
-
dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-print("------------------------before tokenize----------------------------")
+print("------------------------before tokenization----------------------------")
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
+for data in dataset.create_dict_iterator(output_numpy=True):
print(text.to_str(data['text']))
tokenizer_op = text.WhitespaceTokenizer()
-
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
dataset = dataset.map(operations=tokenizer_op)
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text']).tolist()
- print(token)
-```
+print("------------------------after tokenization-----------------------------")
+for i in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+ print(text.to_str(i['text']).tolist())
```
->> Tokenize Result
-------------------------before tokenize----------------------------
+
+输出结果如下：
+
+```text
+------------------------before tokenization----------------------------
Welcome to Beijing!
北京欢迎您！
我喜欢English!
-------------------------after tokenize-----------------------------
+------------------------after tokenization-----------------------------
['Welcome', 'to', 'Beijing!']
['北京欢迎您！']
['我喜欢English!']
@@ -403,42 +260,40 @@ Welcome to Beijing!
### WordpieceTokenizer
-`WordpieceTokenizer`是基于单词集来划分的，单词集里没有的，但是有组合的也会划分出来。
+`WordpieceTokenizer`是基于单词集来进行划分的，划分依据可以是单词集中的单个单词，或者多个单词的组合形式。
+
+下面的样例首先构建了一个文本数据集，然后从单词列表中构建`vocab`对象，通过`WordpieceTokenizer`对数据集进行分词，并展示了分词前后的文本结果。
```python
import mindspore.dataset as ds
import mindspore.dataset.text as text
-# 构建输入的数据列表
-input_list = ["my", "favorite", "book", "is", "love", "during", "the", "cholera", "era", "what", "我", "最", "喜", "欢", "的", "书", "是", "霍", "乱", "时", "期", "的", "爱", "情", "您"]
+input_list = ["my", "favorite", "book", "is", "love", "during", "the", "cholera", "era", "what",
+ "我", "最", "喜", "欢", "的", "书", "是", "霍", "乱", "时", "期", "的", "爱", "情", "您"]
+vocab_english = ["book", "cholera", "era", "favor", "##ite", "my", "is", "love", "dur", "##ing", "the"]
+vocab_chinese = ["我", '最', '喜', '欢', '的', '书', '是', '霍', '乱', '时', '期', '爱', '情']
dataset = ds.NumpySlicesDataset(input_list, column_names=["text"], shuffle=False)
-print("------------------------before tokenize----------------------------")
+print("------------------------before tokenization----------------------------")
-# 输出分词之前的数据
-for data in dataset.create_dict_iterator():
+for data in dataset.create_dict_iterator(output_numpy=True):
print(text.to_str(data['text']))
-#打印分词后的数据输出
-print("------------------------after tokenize-----------------------------")
-
-# 从单词列表中构建一个vocab对象
-vocab = text.Vocab.from_list(vocab_list)
-
-# 输出分词之后的数据
-# BasicTokenizer为分词的函数
+vocab = text.Vocab.from_list(vocab_english+vocab_chinese)
tokenizer_op = text.WordpieceTokenizer(vocab=vocab)
-
dataset = dataset.map(operations=tokenizer_op)
-for i in dataset.create_dict_iterator(num_epochs=1):
- token = text.to_str(i['text'])
- print(token)
-```
+print("------------------------after tokenization-----------------------------")
+for i in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+ print(text.to_str(i['text']))
```
-------------------------before tokenize----------------------------
+
+输出结果如下：
+
+```text
+------------------------before tokenization----------------------------
my
favorite
book
@@ -464,7 +319,7 @@ what
爱
情
您
-------------------------after tokenize-----------------------------
+------------------------after tokenization-----------------------------
['my']
['favor' '##ite']
['book']
diff --git a/docs/programming_guide/source_zh_cn/train.md b/docs/programming_guide/source_zh_cn/train.md
new file mode 100644
index 0000000000000000000000000000000000000000..29e89b40c0b7bf883678e2994ed877ac1bcfb2d4
--- /dev/null
+++ b/docs/programming_guide/source_zh_cn/train.md
@@ -0,0 +1,456 @@
+# 训练
+
+
+
+- [训练](#训练)
+ - [概述](#概述)
+ - [自定义训练网络](#自定义训练网络)
+ - [自定义训练循环](#自定义训练循环)
+ - [边训练边推理](#边训练边推理)
+ - [on-device执行](#on-device执行)
+ - [计算图下沉](#计算图下沉)
+ - [数据下沉](#数据下沉)
+
+
+
+
+
+## 概述
+
+MindSpore在Model_zoo也已经提供了大量的目标检测、自然语言处理等多种网络模型，供用户直接使用，但是对于某些高级用户而言可能想要自行设计网络或者自定义训练循环，下面就对自定义训练网络、自定义训练循环和边训练边推理三种场景进行介绍，另外对On device执行方式进行详细介绍。
+
+## 自定义训练网络
+
+在自定义训练网络前，需要先了解下MindSpore的网络支持、Python源码构造网络约束和算子支持情况。
+
+- 网络支持：当前MindSpore已经支持多种网络，按类型分为计算机视觉、自然语言处理、推荐和图神经网络，可以通过[网络支持](https://www.mindspore.cn/doc/note/zh-CN/r1.0/network_list.html)查看具体支持的网络情况。如果现有网络无法满足用户需求，用户可以根据实际需要定义自己的网络。
+
+- Python源码构造网络约束：MindSpore暂不支持将任意Python源码转换成计算图，所以对于用户源码支持的写法有所限制，主要包括语法约束和网络定义约束两方面。详细情况可以查看[Python源码构造网络约束](https://www.mindspore.cn/doc/note/zh-CN/r1.0/constraints_on_network_construction.html)了解。随着MindSpore的演进，这些约束可能会发生变化。
+
+- 算子支持：顾名思义，网络的基础是算子，所以用户自定义训练网络前要对MindSpore当前支持的算子有所了解，可以通过查看[算子支持](https://www.mindspore.cn/doc/note/zh-CN/r1.0/operator_list.html)了解不同的后端（Ascend、GPU和CPU）的算子实现情况。
+
+> 当开发网络遇到内置算子不足以满足需求时，用户也可以参考[自定义算子](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/custom_operator_ascend.html)，方便快捷地扩展昇腾AI处理器的自定义算子。
+
+代码样例如下：
+
+```python
+import numpy as np
+
+from mindspore.common.tensor import Tensor
+from mindspore.nn import Cell, Dense, SoftmaxCrossEntropyWithLogits, Momentum, TrainOneStepCell, WithLossCell
+import mindspore.ops as ops
+
+
+class ReLUReduceMeanDense(Cell):
+ def __init__(self, kernel, bias, in_channel, num_class):
+ super().__init__()
+ self.relu = ops.ReLU()
+ self.mean = ops.ReduceMean(keep_dims=False)
+ self.dense = Dense(in_channel, num_class, kernel, bias)
+
+ def construct(self, x):
+ x = self.relu(x)
+ x = self.mean(x, (2, 3))
+ x = self.dense(x)
+ return x
+
+
+if __name__ == "__main__":
+ weight_np = np.ones((1000, 2048)).astype(np.float32)
+ weight = Tensor(weight_np.copy())
+ bias_np = np.ones((1000,)).astype(np.float32)
+ bias = Tensor(bias_np.copy())
+ net = ReLUReduceMeanDense(weight, bias, 2048, 1000)
+ criterion = SoftmaxCrossEntropyWithLogits(sparse=False)
+ optimizer = Momentum(learning_rate=0.1, momentum=0.1,
+ params=filter(lambda x: x.requires_grad, net.get_parameters()))
+ net_with_criterion = WithLossCell(net, criterion)
+ train_network = TrainOneStepCell(net_with_criterion, optimizer)
+ train_network.set_train()
+ input_np = np.random.randn(32, 2048, 7, 7).astype(np.float32)
+ input = Tensor(input_np.copy())
+ label_np_onehot = np.zeros(shape=(32, 1000)).astype(np.float32)
+ label = Tensor(label_np_onehot.copy())
+ for i in range(1):
+ loss = train_network(input, label)
+ print("-------loss------", loss)
+```
+
+输出如下：
+
+```python
+-------loss------ [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.
+ 0. 0. 0. 0. 0. 0. 0. 0.]
+```
+
+## 自定义训练循环
+
+用户如果不想使用MindSpore提供的Model接口，可以将模仿Model的train接口自由控制循环的迭代次数和每个epoch的step数量。
+
+代码样例如下：
+
+```python
+import os
+
+import mindspore.dataset as ds
+import mindspore.dataset.transforms.c_transforms as CT
+import mindspore.dataset.vision.c_transforms as CV
+import mindspore.nn as nn
+from mindspore import context
+from mindspore.common import dtype as mstype
+from mindspore.common.initializer import TruncatedNormal
+from mindspore.common.parameter import ParameterTuple
+from mindspore.dataset.vision import Inter
+from mindspore.nn.wrap.cell_wrapper import WithLossCell
+import mindspore.ops as ops
+from mindspore.train.dataset_helper import DatasetHelper, connect_network_with_dataset
+
+
+def create_dataset(data_path, batch_size=32, repeat_size=1,
+ num_parallel_workers=1):
+ """
+ create dataset for train or test
+ """
+ # define dataset
+ mnist_ds = ds.MnistDataset(data_path)
+
+ resize_height, resize_width = 32, 32
+ rescale = 1.0 / 255.0
+ shift = 0.0
+ rescale_nml = 1 / 0.3081
+ shift_nml = -1 * 0.1307 / 0.3081
+
+ # define map operations
+ resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR) # Bilinear mode
+ rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)
+ rescale_op = CV.Rescale(rescale, shift)
+ hwc2chw_op = CV.HWC2CHW()
+ type_cast_op = CT.TypeCast(mstype.int32)
+
+ # apply map operations on images
+ mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)
+
+ # apply DatasetOps
+ buffer_size = 10000
+ mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size) # 10000 as in LeNet train script
+ mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
+ mnist_ds = mnist_ds.repeat(repeat_size)
+
+ return mnist_ds
+
+
+def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
+ """weight initial for conv layer"""
+ weight = weight_variable()
+ return nn.Conv2d(in_channels, out_channels,
+ kernel_size=kernel_size, stride=stride, padding=padding,
+ weight_init=weight, has_bias=False, pad_mode="valid")
+
+
+def fc_with_initialize(input_channels, out_channels):
+ """weight initial for fc layer"""
+ weight = weight_variable()
+ bias = weight_variable()
+ return nn.Dense(input_channels, out_channels, weight, bias)
+
+
+def weight_variable():
+ """weight initial"""
+ return TruncatedNormal(0.02)
+
+
+class LeNet5(nn.Cell):
+ """
+ Lenet network
+ Args:
+ num_class (int): Num classes. Default: 10.
+
+ Returns:
+ Tensor, output tensor
+
+ Examples:
+ >>> LeNet(num_class=10)
+ """
+
+ def __init__(self, num_class=10):
+ super(LeNet5, self).__init__()
+ self.num_class = num_class
+ self.batch_size = 32
+ self.conv1 = conv(1, 6, 5)
+ self.conv2 = conv(6, 16, 5)
+ self.fc1 = fc_with_initialize(16 * 5 * 5, 120)
+ self.fc2 = fc_with_initialize(120, 84)
+ self.fc3 = fc_with_initialize(84, self.num_class)
+ self.relu = nn.ReLU()
+ self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
+ self.reshape = ops.Reshape()
+
+ def construct(self, x):
+ x = self.conv1(x)
+ x = self.relu(x)
+ x = self.max_pool2d(x)
+ x = self.conv2(x)
+ x = self.relu(x)
+ x = self.max_pool2d(x)
+ x = self.reshape(x, (self.batch_size, -1))
+ x = self.fc1(x)
+ x = self.relu(x)
+ x = self.fc2(x)
+ x = self.relu(x)
+ x = self.fc3(x)
+ return x
+
+
+class TrainOneStepCell(nn.Cell):
+ def __init__(self, network, optimizer, sens=1.0):
+ super(TrainOneStepCell, self).__init__(auto_prefix=False)
+ self.network = network
+ self.weights = ParameterTuple(network.trainable_params())
+ self.optimizer = optimizer
+ self.grad = ops.GradOperation(get_by_list=True, sens_param=True)
+ self.sens = sens
+
+ def set_sens(self, value):
+ self.sens = value
+
+ def construct(self, data, label):
+ weights = self.weights
+ loss = self.network(data, label)
+ sens = ops.Fill()(ops.DType()(loss), ops.Shape()(loss), self.sens)
+ grads = self.grad(self.network, weights)(data, label, sens)
+ return ops.depend(loss, self.optimizer(grads))
+
+
+if __name__ == "__main__":
+ context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+ ds_train = create_dataset(os.path.join("/home/workspace/mindspore_dataset/MNIST_Data/", "train"), 32)
+
+ network = LeNet5(10)
+ net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
+ net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
+ net = WithLossCell(network, net_loss)
+ net = TrainOneStepCell(net, net_opt)
+ dataset_helper = DatasetHelper(ds_train, dataset_sink_mode=True, sink_size=100, epoch_num=10)
+ net = connect_network_with_dataset(net, dataset_helper)
+ network.set_train()
+ print("============== Starting Training ==============")
+ epoch = 10
+ for step in range(epoch):
+ for inputs in dataset_helper:
+ output = net(*inputs)
+ print("epoch: {0}/{1}, losses: {2}".format(step + 1, epoch, output.asnumpy(), flush=True))
+```
+
+> 示例中用到的MNIST数据集的获取方法，可以参照[实现一个图片分类应用](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/quick_start/quick_start.html)的下载数据集部分，下同。
+
+输出如下：
+
+```python
+epoch: 1/10, losses: 2.294034719467163
+epoch: 2/10, losses: 2.3150298595428467
+epoch: 3/10, losses: 2.3107073307037354
+epoch: 4/10, losses: 2.3155436515808105
+epoch: 5/10, losses: 2.28973388671875
+epoch: 6/10, losses: 2.3108928203582764
+epoch: 7/10, losses: 2.293713092803955
+epoch: 8/10, losses: 2.29837703704834
+epoch: 9/10, losses: 2.305952548980713
+epoch: 10/10, losses: 1.4282708168029785
+```
+
+> 典型的使用场景是梯度累积，详细查看[梯度累积](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/apply_gradient_accumulation.html)。
+
+## 边训练边推理
+
+对于某些数据量较大、训练时间较长的复杂网络，为了能掌握训练的不同阶段模型精度的指标变化情况，可以通过边训练边推理的方式跟踪精度的变化情况。具体可以参考[同步训练和验证模型](https://www.mindspore.cn/tutorial/training/zh-CN/r1.0/advanced_use/evaluate_the_model_during_training.html)。
+
+## on-device执行
+
+当前MindSpore支持的后端包括Ascend、GPU、CPU，所谓On Device中的Device通常指Ascend（昇腾）AI处理器。
+
+昇腾芯片上集成了AICORE、AICPU和CPU。其中，AICORE负责大型Tensor Vector运算，AICPU负责标量运算，CPU负责逻辑控制和任务分发。
+
+Host侧CPU负责将图或算子下发到昇腾芯片。昇腾芯片由于具备了运算、逻辑控制和任务分发的功能，所以不需要与Host侧的CPU进行频繁的交互，只需要将计算完的最终结果返回给Host侧，实现整图下沉到Device执行，避免Host-Device频繁交互，减小了开销。
+
+以下是Device的主要组成结构：
+
+- 片上32G内存：5G(parameter) + 26G(feature map) + 1G(HCCL)
+- 多流水线并行：6条流水线
+- AICORE&带宽：32Cores、读写带宽128GBps
+- 通信协议：HCCS、PCIe4.0、RoCEv2
+
+### 计算图下沉
+
+计算图整图下沉到Device上执行，减少Host-Device交互开销。可以结合循环下沉实现多个Step下沉，进一步减少Host和Device的交互次数。
+
+循环下沉是在On Device执行的基础上的优化，目的是进一步减少Host侧和Device侧之间的交互次数。通常情况下，每个step都返回一个结果，循环下沉是控制每隔多少个step返回一次结果。
+
+默认配置下是每一个epoch返回一次结果，这样每个epoch里，Host侧和Device侧只需要进行一次数据交互。
+
+也可以结合`train`接口的`dataset_sink_mode`和`sink_size`控制每个epoch的下沉数据量。
+
+### 数据下沉
+
+`Model`的`train`接口参数`dataset_sink_mode`可以控制数据是否下沉。`dataset_sink_mode`为True表示数据下沉，否则为非下沉。所谓下沉即数据通过通道直接传送到Device上。
+
+dataset_sink_mode参数可以配合`sink_size`控制每个`epoch`下沉的数据量大小。当`dataset_sink_mode`设置为True，即数据下沉模式时：
+
+如果`sink_size`为默认值-1，则每一个`epoch`下沉的数据量为原始的整个数据集大小；
+
+如果`sink_size`>0，此时原始数据集可以被无限次遍历，每个`epoch`下沉`sink_size`大小的数据量，下一个`epoch`继续从上次遍历的结束位置继续遍历。
+
+下沉的总数据量由`epoch`和`sink_size`两个变量共同控制，即总数据量=`epoch`*`sink_size`。
+
+代码样例如下：
+
+```python
+import os
+
+import mindspore.dataset as ds
+import mindspore.dataset.transforms.c_transforms as CT
+import mindspore.dataset.vision.c_transforms as CV
+import mindspore.nn as nn
+from mindspore import context
+from mindspore.common import dtype as mstype
+from mindspore.common.initializer import TruncatedNormal
+from mindspore.dataset.vision import Inter
+from mindspore.nn.metrics import Accuracy
+import mindspore.ops as ops
+from mindspore.train import Model
+from mindspore.train.callback import LossMonitor
+
+
+def create_dataset(data_path, batch_size=32, repeat_size=1,
+ num_parallel_workers=1):
+ """
+ create dataset for train or test
+ """
+ # define dataset
+ mnist_ds = ds.MnistDataset(data_path)
+
+ resize_height, resize_width = 32, 32
+ rescale = 1.0 / 255.0
+ shift = 0.0
+ rescale_nml = 1 / 0.3081
+ shift_nml = -1 * 0.1307 / 0.3081
+
+ # define map operations
+ resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR) # Bilinear mode
+ rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)
+ rescale_op = CV.Rescale(rescale, shift)
+ hwc2chw_op = CV.HWC2CHW()
+ type_cast_op = CT.TypeCast(mstype.int32)
+
+ # apply map operations on images
+ mnist_ds = mnist_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=resize_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=rescale_nml_op, num_parallel_workers=num_parallel_workers)
+ mnist_ds = mnist_ds.map(input_columns="image", operations=hwc2chw_op, num_parallel_workers=num_parallel_workers)
+
+ # apply DatasetOps
+ buffer_size = 10000
+ mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size) # 10000 as in LeNet train script
+ mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
+ mnist_ds = mnist_ds.repeat(repeat_size)
+
+ return mnist_ds
+
+
+def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):
+ """weight initial for conv layer"""
+ weight = weight_variable()
+ return nn.Conv2d(in_channels, out_channels,
+ kernel_size=kernel_size, stride=stride, padding=padding,
+ weight_init=weight, has_bias=False, pad_mode="valid")
+
+
+def fc_with_initialize(input_channels, out_channels):
+ """weight initial for fc layer"""
+ weight = weight_variable()
+ bias = weight_variable()
+ return nn.Dense(input_channels, out_channels, weight, bias)
+
+
+def weight_variable():
+ """weight initial"""
+ return TruncatedNormal(0.02)
+
+
+class LeNet5(nn.Cell):
+ """
+ Lenet network
+ Args:
+ num_class (int): Num classes. Default: 10.
+
+ Returns:
+ Tensor, output tensor
+
+ Examples:
+ >>> LeNet(num_class=10)
+ """
+
+ def __init__(self, num_class=10):
+ super(LeNet5, self).__init__()
+ self.num_class = num_class
+ self.batch_size = 32
+ self.conv1 = conv(1, 6, 5)
+ self.conv2 = conv(6, 16, 5)
+ self.fc1 = fc_with_initialize(16 * 5 * 5, 120)
+ self.fc2 = fc_with_initialize(120, 84)
+ self.fc3 = fc_with_initialize(84, self.num_class)
+ self.relu = nn.ReLU()
+ self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
+ self.reshape = ops.Reshape()
+
+ def construct(self, x):
+ x = self.conv1(x)
+ x = self.relu(x)
+ x = self.max_pool2d(x)
+ x = self.conv2(x)
+ x = self.relu(x)
+ x = self.max_pool2d(x)
+ x = self.reshape(x, (self.batch_size, -1))
+ x = self.fc1(x)
+ x = self.relu(x)
+ x = self.fc2(x)
+ x = self.relu(x)
+ x = self.fc3(x)
+ return x
+
+
+if __name__ == "__main__":
+ context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
+ ds_train = create_dataset(os.path.join("/home/workspace/mindspore_dataset/MNIST_Data/", "train"), 32)
+
+ network = LeNet5(10)
+ net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
+ net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
+ model = Model(network, net_loss, net_opt)
+
+ print("============== Starting Training ==============")
+ model.train(epoch=10, train_dataset=ds_train, callbacks=[LossMonitor()], dataset_sink_mode=True, sink_size=1000)
+```
+
+`batch_size`为32的情况下，数据集的大小为1875，当`sink_size`设置为1000时，表示每个`epoch`下沉1000个batch的数据，下沉次数为`epoch`=10，下沉的总数据量为：`epoch`*`sink_size`=10000。
+
+输出如下：
+
+```python
+epoch: 1 step: 1000, loss is 0.5399815
+epoch: 2 step: 1000, loss is 0.033433747
+epoch: 3 step: 1000, loss is 0.054761313
+epoch: 4 step: 1000, loss is 0.007882872
+epoch: 5 step: 1000, loss is 0.00658499
+epoch: 6 step: 1000, loss is 0.0413095
+epoch: 7 step: 1000, loss is 0.13373856
+epoch: 8 step: 1000, loss is 0.015793817
+epoch: 9 step: 1000, loss is 0.00017951085
+epoch: 10 step: 1000, loss is 0.01490275
+```
+
+> `dataset_sink_mode`为False时，`sink_size`参数设置无效。
diff --git a/docs/source_en/FAQ.md b/docs/source_en/FAQ.md
deleted file mode 100644
index 153aaf1e004ca93f5752dd32ea114f0895cbf2d2..0000000000000000000000000000000000000000
--- a/docs/source_en/FAQ.md
+++ /dev/null
@@ -1,300 +0,0 @@
-# FAQ
-
-`Linux` `Windows` `Ascend` `GPU` `CPU` `Environmental Setup` `Model Export` `Model Training` `Beginner` `Intermediate` `Expert`
-
-
-
-- [FAQ](#faq)
- - [Installation](#installation)
- - [Installing Using pip](#installing-using-pip)
- - [Source Code Compilation Installation](#source-code-compilation-installation)
- - [Environment Variables](#environment-variables)
- - [Verifying the Installation](#verifying-the-installation)
- - [Supported Operators](#supported-operators)
- - [Network Models](#network-models)
- - [Platform and System](#platform-and-system)
- - [Backend Running](#backend-running)
- - [Programming Language Extensions](#programming-language-extensions)
- - [Supported Features](#supported-features)
-
-
-
-
-## Installation
-
-### Installing Using pip
-
-Q: What can I do if an error message `cannot open shared object file:file such file or directory` is displayed when I install MindSpore of the GPU, CUDA 10.1, 0.5.0-beta, or Ubuntu-x86 version?
-
-A: The error message indicates that the cuBLAS library is not found. Generally, the cause is that the cuBLAS library is not installed or is not added to the environment variable. Generally, cuBLAS is installed together with CUDA and the driver. After the installation, add the directory where cuBLAS is located to the `LD_LIBRARY_PATH` environment variable.
-
-
-
-## Model Zoo
-
-| Domain | Sub Domain | Network | Ascend | GPU | CPU
-|:------ |:------| :----------- |:------ |:------ |:-----
-|Computer Vision (CV) | Image Classification | [AlexNet](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/alexnet/src/alexnet.py) | Supported | Supported | Doing
-| Computer Vision (CV) | Image Classification | [GoogleNet](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/googlenet/src/googlenet.py) | Supported | Doing | Doing
-| Computer Vision (CV) | Image Classification | [LeNet](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/lenet/src/lenet.py) | Supported | Supported | Supported
-| Computer Vision (CV) | Image Classification | [ResNet-50](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Supported | Doing
-|Computer Vision (CV) | Image Classification | [ResNet-101](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnet/src/resnet.py) | Supported |Doing | Doing
-|Computer Vision (CV) | Image Classification | [SE-ResNet50](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnet/src/resnet.py) | Supported |Doing | Doing
-|Computer Vision (CV) | Image Classification | [ResNext50](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnext50/src/image_classification.py) | Supported | Supported | Doing
-| Computer Vision (CV) | Image Classification | [VGG16](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/vgg16/src/vgg.py) | Supported | Doing | Doing
-| Computer Vision (CV) | Image Classification | [InceptionV3](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/inceptionv3/src/inception_v3.py) | Supported | Doing | Doing
-| Computer Vision (CV) | Mobile Image Classification
-
-## mindspore.nn
-
-| Operation | Ascend | GPU | CPU |Operator Type
-| :----------- |:------ |:------ |:-----|:---
-| [mindspore.nn.Softmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Softmax) | Supported | Supported | Supported |layer/activation
-| [mindspore.nn.LogSoftmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LogSoftmax) | Supported | Supported | Doing |layer/activation
-| [mindspore.nn.ReLU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ReLU) | Supported | Supported | Supported |layer/activation
-| [mindspore.nn.ReLU6](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ReLU6) |Supported | Supported | Supported |layer/activation
-| [mindspore.nn.HSwish](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.HSwish) | Doing | Supported | Doing |layer/activation
-| [mindspore.nn.HSigmoid](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.HSigmoid) | Doing | Supported | Doing |layer/activation
-| [mindspore.nn.LeakyReLU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LeakyReLU) | Supported |Supported | Doing |layer/activation
-| [mindspore.nn.Tanh](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Tanh) | Supported | Supported | Doing |layer/activation
-| [mindspore.nn.GELU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GELU) | Supported | Supported | Doing |layer/activation
-| [mindspore.nn.Sigmoid](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Sigmoid) | Supported |Supported | Doing |layer/activation
-| [mindspore.nn.PReLU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.PReLU) | Supported |Doing | Doing |layer/activation
-| [mindspore.nn.Dropout](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Dropout) |Supported | Supported | Supported |layer/basic
-| [mindspore.nn.Flatten](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Flatten) |Supported | Supported | Supported |layer/basic
-| [mindspore.nn.Dense](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Dense) |Supported | Supported | Supported |layer/basic
-| [mindspore.nn.ClipByNorm](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ClipByNorm) |Supported | Supported | Doing |layer/basic
-| [mindspore.nn.Norm](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Norm) |Doing | Supported | Doing |layer/basic
-| [mindspore.nn.OneHot](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.OneHot) | Supported | Supported | Supported |layer/basic
-| [mindspore.nn.Range](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Range) | Supported | Doing | Doing |layer/basic
-| [mindspore.nn.SequentialCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SequentialCell) |Supported | Supported | Doing |layer/container
-| [mindspore.nn.CellList](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CellList) | Supported | Supported | Doing |layer/container
-| [mindspore.nn.Conv2d](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv2d) | Supported | Supported | Supported |layer/conv
-| [mindspore.nn.Conv2dTranspose](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv2dTranspose) | Supported | Supported | Doing |layer/conv
-| [mindspore.nn.Conv1d](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv1d) | Supported | Supported | Doing |layer/conv
-| [mindspore.nn.Conv1dTranspose](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv1dTranspose) | Supported | Supported | Doing |layer/conv
-| [mindspore.nn.Embedding](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Embedding) |Supported | Supported | Doing |layer/embedding
-| [mindspore.nn.ImageGradients](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ImageGradients) | Supported |Supported | Doing |layer/image
-| [mindspore.nn.SSIM](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SSIM) | Supported | Supported | Doing |layer/image
-| [mindspore.nn.PSNR](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.PSNR) | Supported |Doing | Doing |layer/image
-| [mindspore.nn.CentralCrop](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CentralCrop) | Supported |Doing | Doing |layer/image
-| [mindspore.nn.LSTM](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LSTM) | Doing | Supported | Supported |layer/lstm
-| [mindspore.nn.GlobalBatchNorm](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GlobalBatchNorm) | Supported |Doing | Doing |layer/normalization
-| [mindspore.nn.BatchNorm1d](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm1d) | Supported |Doing | Doing |layer/normalization
-| [mindspore.nn.BatchNorm2d](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm2d) | Supported | Supported | Doing |layer/normalization
-| [mindspore.nn.GroupNorm](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GroupNorm) | Supported | Doing | Doing |layer/normalization
-| [mindspore.nn.LayerNorm](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LayerNorm) | Supported | Supported | Doing |layer/normalization
-| [mindspore.nn.MatrixDiag](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiag) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.MatrixDiagPart](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiagPart) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.MatrixSetDiag](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MatrixSetDiag) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.LinSpace](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LinSpace) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.MaxPool2d](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MaxPool2d) | Supported | Supported | Supported |layer/pooling
-| [mindspore.nn.AvgPool2d](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.AvgPool2d) | Supported | Supported | Doing |layer/pooling
-| [mindspore.nn.DenseBnAct](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DenseBnAct) |Supported | Doing | Doing |layer/quant
-| [mindspore.nn.Conv2dBnAct](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnAct) | Supported | Supported | Doing |layer/quant
-| [mindspore.nn.L1Loss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.L1Loss) |Supported |Supported | Doing |loss/loss
-| [mindspore.nn.MSELoss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MSELoss) | Supported |Doing | Doing |loss/loss
-| [mindspore.nn.SmoothL1Loss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SmoothL1Loss) |Supported |Doing | Doing |loss/loss
-| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits) | Supported | Supported | Supported |loss/loss
-| [mindspore.nn.SoftmaxCrossEntropyExpand](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyExpand) | Supported |Supported | Doing |loss/loss
-| [mindspore.nn.CosineEmbeddingLoss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CosineEmbeddingLoss) |Supported |Supported | Doing |loss/loss
-| [mindspore.nn.ProximalAdagrad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ProximalAdagrad) | Supported | Doing | Doing |optim/ProximalAdagrad
-| [mindspore.nn.LazyAdam](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LazyAdam) | Supported | Doing | Doing |optim/lazyadam
-| [mindspore.nn.Adam](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Adam) | Supported |Doing | Doing |optim/adam
-| [mindspore.nn.AdamWeightDecay](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.AdamWeightDecay) | Supported | Supported | Doing |optim/adam
-| [mindspore.nn.Lamb](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Lamb) | Supported | Supported | Doing |optim/lamb
-| [mindspore.nn.LARS](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LARS) |Supported |Doing | Doing |optim/lars
-| [mindspore.nn.Momentum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Momentum) | Supported | Supported | Supported |optim/momentum
-| [mindspore.nn.Optimizer](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Optimizer) | Supported | Supported | Doing |optim/optimizer
-| [mindspore.nn.RMSProp](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.RMSProp) | Supported | Support | Doing |optim/optimizer
-| [mindspore.nn.SGD](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SGD) |Supported |Doing | Doing |optim/sgd
-| [mindspore.nn.WithLossCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.WithLossCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.WithGradCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.WithGradCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.TrainOneStepCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.DataWrapper](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DataWrapper) |Doing | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.GetNextSingleOp](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GetNextSingleOp) |Doing | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.WithEvalCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.WithEvalCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.ParameterUpdate](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ParameterUpdate) | Supported |Doing | Doing |wrap/cell_wrapper
-| [mindspore.nn.DistributedGradReducer](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DistributedGradReducer) | Supported |Doing | Doing |wrap/grad_reducer
-| [mindspore.nn.DynamicLossScaleUpdateCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DynamicLossScaleUpdateCell) | Doing |Doing | Doing |wrap/loss_scale
-| [mindspore.nn.FixedLossScaleUpdateCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.FixedLossScaleUpdateCell) | Doing |Doing | Doing |wrap/loss_scale
-| [mindspore.nn.TrainOneStepWithLossScaleCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepWithLossScaleCell) | Doing |Doing | Doing |wrap/loss_scale
-| [mindspore.nn.Cell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Cell) | Supported | Supported | Supported |cell
-
-## mindspore.ops.operations
-
-| Operation | Ascend | GPU | CPU |Operator Type
-| :----------- |:------ |:------ |:-----|:---
-| [mindspore.ops.operations.Flatten](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Flatten) | Supported | Supported |Supported | nn_ops
-| [mindspore.ops.operations.Softmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softmax) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.Acosh](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Acosh) | Doing | Doing | Doing | nn_ops
-| [mindspore.ops.operations.FloorMod](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorMod) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.Elu](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Elu) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.MirrorPad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MirrorPad) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.Unpack](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Unpack) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.Pack](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pack) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.L2Loss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.L2Loss) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.CTCLoss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CTCLoss) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.RNNTLoss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RNNTLoss) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.LogSoftmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogSoftmax) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Softplus](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softplus) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.ReLU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReLU) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.ReLU6](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReLU6) | Supported | Supported |Supported | nn_ops
-| [mindspore.ops.operations.HSwish](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HSwish) | Doing | Supported |Doing | nn_ops
-| [mindspore.ops.operations.HSigmoid](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HSigmoid) | Doing | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Sigmoid](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sigmoid) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Tanh](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tanh) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.BatchNorm](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchNorm) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.LRN](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LRN) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.Conv2D](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Conv2D) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.DepthwiseConv2dNative](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthwiseConv2dNative) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.DepthwiseConv2dNativeBackpropInput](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthwiseConv2dNativeBackpropInput) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.DepthwiseConv2dNativeiBackpropFilter](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthwiseConv2dNativeBackpropFilter) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.MaxPoolWithArgmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MaxPoolWithArgmax) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.MaxPool](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MaxPool) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.AvgPool](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AvgPool) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Conv2DBackpropInput](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Conv2DBackpropInput) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.BiasAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BiasAdd) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.TopK](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TopK) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SoftmaxCrossEntropyWithLogits) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.SparseSoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseSoftmaxCrossEntropyWithLogits) | Doing | Supported | Supported | nn_ops
-| [mindspore.ops.operations.ApplyMomentum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyMomentum) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.ApplyAddSign](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyAddSign) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyPowerSign](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyPowerSign) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyGradientDescent](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyGradientDescent) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyProximalGradientDescent](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyProximalGradientDescent) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyRMSProp](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyRMSProp) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.ApplyCenteredRMSProp](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyCenteredRMSProp) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.SparseApplyAdagrad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyAdagrad) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.SparseApplyAdagradV2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyAdagradV2) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.SparseApplyProximalAdagrad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.FusedSparseProximalAdagrad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseProximalAdagrad) | Doing | Doing | Supported | nn_ops
-| [mindspore.ops.operations.ApplyProximalAdagrad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.FusedSparseLazyAdam](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseLazyAdam) | Doing | Doing | Supported | nn_ops
-| [mindspore.ops.operations.FusedSparseAdam](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseAdam) | Doing | Doing | Supported | nn_ops
-| [mindspore.ops.operations.SmoothL1Loss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SmoothL1Loss) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.SGD](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SGD) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.LayerNorm](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LayerNorm) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.L2Normalize](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.L2Normalize) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.DropoutGenMask](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutGenMask) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.DropoutDoMask](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutDoMask) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ResizeBilinear](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ResizeBilinear) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.OneHot](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OneHot) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.Gelu](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Gelu) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.GetNext](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GetNext) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.PReLU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.PReLU) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.LSTM](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LSTM) | Doing | Supported | Supported | nn_ops
-| [mindspore.ops.operations.BasicLSTMCell](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BasicLSTMCell) | Doing | Doing | Doing | nn_ops
-| [mindspore.ops.operations.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SigmoidCrossEntropyWithLogits) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.Pad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pad) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.ROIAlign](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ROIAlign) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.Adam](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Adam) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.BinaryCrossEntropy](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BinaryCrossEntropy) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.KLDivLoss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.KLDivLoss) | Doing | Supported | Doing | nn_ops
-| [mindspore.ops.operations.LARSUpdate](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LARSUpdate) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.Softsign](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softsign) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.TensorAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorAdd) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.AssignAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignAdd) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.AssignSub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignSub) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ReduceMean](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMean) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.ReduceSum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceSum) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.ReduceAll](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceAll) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ReduceMax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMax) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.ReduceMin](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMin) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.ReduceProd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceProd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.CumProd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CumProd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.MatMul](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MatMul) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.BatchMatMul](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchMatMul) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.CumSum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CumSum) | Supported | Supported| Doing | math_ops
-| [mindspore.ops.operations.AddN](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AddN) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.Neg](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Neg) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Sub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sub) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.Mul](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mul) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.Square](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Square) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.SquareSumAll](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SquareSumAll) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Rsqrt](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rsqrt) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Sqrt](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sqrt) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Reciprocal](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reciprocal) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Pow](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pow) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Exp](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Exp) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Log](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Log) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Log1p](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Log1p) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Minimum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Minimum) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Maximum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Maximum) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.RealDiv](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RealDiv) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Div](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Div) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.DivNoNan](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DivNoNan) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.FloorDiv](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorDiv) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Floor](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Floor) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Equal](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Equal) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.EqualCount](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.EqualCount) | Doing | Supported | Supported | math_ops
-| [mindspore.ops.operations.NotEqual](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NotEqual) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Greater](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Greater) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.GreaterEqual](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GreaterEqual) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Less](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Less) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Atan2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Atan2) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.LessEqual](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LessEqual) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.LogicalNot](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalNot) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.LogicalAnd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalAnd) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.LogicalOr](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalOr) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.BitwiseAnd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseAnd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BitwiseOr](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseOr) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Ceil](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Ceil) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Inv](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Inv) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Invert](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Invert) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BitwiseXor](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseXor) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NPUAllocFloatStatus](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NPUAllocFloatStatus) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NPUGetFloatStatus](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NPUGetFloatStatus) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NPUClearFloatStatus](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NPUClearFloatStatus) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.FloatStatus](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloatStatus) | Doing | Supported | Doing | math_ops
-| [mindspore.ops.operations.Cos](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cos) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Cosh](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cosh) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ACos](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ACos) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BesselI0e](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BesselI0e) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BesselI1e](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BesselI1e) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.TruncateDiv](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncateDiv) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.TruncateMod](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncateMod) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Tan](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tan) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Asin](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Asin) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Asinh](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Asinh) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Erf](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Erf) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Erfc](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Erfc) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Sin](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sin) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Sinh](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sinh) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Expm1](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Expm1) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NMSWithMask](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NMSWithMask) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Abs](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Abs) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Sign](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sign) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Round](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Round) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ApproximateEqual](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApproximateEqual) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.InplaceAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InplaceAdd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.InplaceSub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InplaceSub) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Mod](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mod) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ExpandDims](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ExpandDims) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.DType](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DType) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.SameTypeShape](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SameTypeShape) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Cast](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cast) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.IsSubClass](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IsSubClass) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.IsInstance](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IsInstance) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Reshape](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reshape) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Shape](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Shape) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Squeeze](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Squeeze) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.Transpose](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Transpose) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.GatherV2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherV2) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Split](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Split) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.Rank](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rank) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.TruncatedNormal](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncatedNormal) | Doing | Doing | Doing | array_ops
-| [mindspore.ops.operations.Size](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Size) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Fill](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Fill) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.OnesLike](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OnesLike) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ZerosLike](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ZerosLike) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.TupleToArray](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TupleToArray) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ScalarToArray](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarToArray) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ScalarToTensor](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarToTensor) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.InvertPermutation](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InvertPermutation) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Argmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Argmax) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Argmin](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Argmin) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ArgMaxWithValue](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMaxWithValue) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ArgMinWithValue](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMinWithValue) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Tile](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tile) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.UnsortedSegmentSum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UnsortedSegmentSum) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.UnsortedSegmentMin](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UnsortedSegmentMin) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.UnsortedSegmentProd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UnsortedSegmentProd) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Concat](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Concat) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ParallelConcat](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ParallelConcat) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Slice](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Slice) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Select](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Select) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.StridedSlice](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.StridedSlice) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Diag](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Diag) | Doing | Doing | Doing | array_ops
-| [mindspore.ops.operations.DiagPart](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DiagPart) | Doing | Doing | Doing | array_ops
-| [mindspore.ops.operations.Eye](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Eye) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ScatterNd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNd) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ResizeNearestNeighbor](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ResizeNearestNeighbor) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.GatherNd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherNd) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ApplyFtrl](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyFtrl) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.SparseApplyFtrl](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyFtrl) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.FusedSparseFtrl](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseFtrl) | Doing | Doing | Supported | array_ops
-| [mindspore.ops.operations.SparseApplyFtrlV2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyFtrlV2) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNdUpdate](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdUpdate) | Supported | Doing | Supported | array_ops
-| [mindspore.ops.operations.ScatterUpdate](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterUpdate) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterMul](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMul) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterDiv](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterDiv) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.SpaceToDepth](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SpaceToDepth) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.DepthToSpace](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthToSpace) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.SpaceToBatch](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SpaceToBatch) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.SpaceToBatchND](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SpaceToBatchND) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.BatchToSpace](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchToSpace) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.BatchToSpaceND](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchToSpaceND) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.IsFinite](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IsFinite) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.InplaceUpdate](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InplaceUpdate) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterSub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterSub) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterMax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMax) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterMin](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMin) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNdAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdAdd) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNdSub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdSub) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNonAliasingAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNonAliasingAdd) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Rint](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rint) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ReverseV2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReverseV2) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ReduceOp](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceOp) | Supported | Supported | Doing | comm_ops
-| [mindspore.ops.operations.AllReduce](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AllReduce) | Supported | Supported | Doing | comm_ops
-| [mindspore.ops.operations.AllGather](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AllGather) | Supported | Supported | Doing | comm_ops
-| [mindspore.ops.operations.ReduceScatter](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceScatter) | Doing | Supported | Doing | comm_ops
-| [mindspore.ops.operations.Broadcast](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Broadcast) | Supported | Doing | Doing | comm_ops
-| [mindspore.ops.operations.ControlDepend](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ControlDepend) | Supported | Supported | Supported | control_ops
-| [mindspore.ops.operations.GeSwitch](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GeSwitch) | Doing | Doing | Doing | control_ops
-| [mindspore.ops.operations.Merge](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Merge) | Doing | Doing | Doing | control_ops
-| [mindspore.ops.operations.ScalarSummary](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.ImageSummary](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ImageSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.TensorSummary](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.HistogramSummary](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HistogramSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.InsertGradientOf](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InsertGradientOf) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.Print](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Print) | Supported | Doing | Doing | debug_ops
-| [mindspore.ops.operations.Assign](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Assign) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.BoundingBoxEncode](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BoundingBoxEncode) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.BoundingBoxDecode](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BoundingBoxDecode) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.PopulationCount](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.PopulationCount) | Supported | Doing | Doing | other_ops
-| [mindspore.ops.operations.CheckValid](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CheckValid) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.IOU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IOU) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.MakeRefKey](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MakeRefKey) | Supported | Supported | Supported | other_ops
-| [mindspore.ops.operations.InTopK](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InTopK) | Supported | Doing | Doing | other_ops
-| [mindspore.ops.operations.StandardNormal](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.StandardNormal) | Supported | Supported | Doing | random_ops
-| [mindspore.ops.operations.Gamma](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Gamma) | Supported | Doing | Doing | random_ops
-| [mindspore.ops.operations.Poisson](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Poisson) | Supported | Doing | Doing | random_ops
-| [mindspore.ops.operations.UniformInt](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UniformInt) | Supported | Supported | Doing | random_ops
-| [mindspore.ops.operations.UniformReal](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UniformReal) | Supported | Supported | Doing | random_ops
-| [mindspore.ops.operations.RandomChoiceWithMask](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RandomChoiceWithMask) | Doing| Supported | Doing | random_ops
-| [mindspore.ops.operations.RandomCategorical](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RandomCategorical) | Supported| Doing | Doing | random_ops
-| [mindspore.ops.operations.ScalarCast](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarCast) | Supported | Supported | Supported | inner_ops
-| [mindspore.ops.operations.ReverseSequence](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReverseSequence) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.CropAndResize](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CropAndResize) | Supported | Doing | Doing | image_ops
-| [mindspore.ops.operations.SquaredDifference](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SquaredDifference) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Xdivy](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Xdivy) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Xlogy](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Xlogy) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.HistogramFixedWidth](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HistogramFixedWidth) | Supported | Doing | Doing | math_ops
-
-## mindspore.ops.functional
-
-| Operation | functional Operation
-| :----------- | :-----------
-| [mindspore.ops.operations.Pack](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pack) | pack
-| [mindspore.ops.operations.TensorAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorAdd) | tensor_add
-| [mindspore.ops.operations.AssignSub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignSub) | assign_sub
-| [mindspore.ops.operations.AddN](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AddN) | addn
-| [mindspore.ops.operations.Square](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Square) | square
-| [mindspore.ops.operations.Sqrt](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sqrt) | sqrt
-| [mindspore.ops.operations.Equal](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Equal) | equal
-| [mindspore.ops.operations.NotEqual](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NotEqual) | not_equal
-| [mindspore.ops.operations.LogicalNot](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalNot) | logical_not
-| [mindspore.ops.operations.LogicalAnd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalAnd) | logical_and
-| [mindspore.ops.operations.LogicalOr](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalOr) | logical_or
-| [mindspore.ops.operations.ExpandDims](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ExpandDims) | expand_dims
-| [mindspore.ops.operations.DType](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DType) | dtype
-| [mindspore.ops.operations.Cast](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cast) | cast
-| [mindspore.ops.operations.Reshape](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reshape) | reshape
-| [mindspore.ops.operations.Shape](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Shape) | shape
-| [mindspore.ops.operations.GatherV2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherV2) | gather
-| [mindspore.ops.operations.Rank](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rank) | rank
-| [mindspore.ops.operations.Size](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Size) | size
-| [mindspore.ops.operations.Fill](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Fill) | fill
-| [mindspore.ops.operations.OnesLike](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OnesLike) | ones_like
-| [mindspore.ops.operations.Tile](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tile) | tile
-| [mindspore.ops.operations.Select](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Select) | select
-| [mindspore.ops.operations.ScatterNd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNd) | scatter_nd
-| [mindspore.ops.operations.GatherNd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherNd) | gather_nd
-| [mindspore.ops.operations.ControlDepend](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ControlDepend) | control_depend
-| [mindspore.ops.operations.Print](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Print) | print
-| [mindspore.ops.operations.Assign](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Assign) | assign
-| [mindspore.ops.operations.Pow](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pow) | tensor_pow
-
-> At present, functional supports some operators without attributes, which will be further completed in the future.
-
-## Distributed Operator
-
-| op name | constraints
-| :----------- | :-----------
-| [mindspore.ops.operations.ACos](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ACos) | None
-| [mindspore.ops.operations.Cos](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cos) | None
-| [mindspore.ops.operations.LogicalNot](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalNot) | None
-| [mindspore.ops.operations.Log](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Log) | None
-| [mindspore.ops.operations.Exp](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Exp) | None
-| [mindspore.ops.operations.LogSoftmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogSoftmax) | The logits can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
-| [mindspore.ops.operations.Softmax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softmax) | The logits can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
-| [mindspore.ops.operations.Tanh](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tanh) | None
-| [mindspore.ops.operations.Gelu](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Gelu) | None
-| [mindspore.ops.operations.ReLU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReLU) | None
-| [mindspore.ops.operations.Sqrt](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sqrt) | None
-| [mindspore.ops.operations.Cast](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cast) | None
-| [mindspore.ops.operations.Neg](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Neg) | None
-| [mindspore.ops.operations.ExpandDims](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ExpandDims) | None
-| [mindspore.ops.operations.Squeeze](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Squeeze) | None
-| [mindspore.ops.operations.Square](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Square) | None
-| [mindspore.ops.operations.Sigmoid](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sigmoid) | None
-| [mindspore.ops.operations.Dropout](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Dropout) | Repeated calculation is not supported.
-| [mindspore.ops.operations.Div](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Div) | None
-| [mindspore.ops.operations.TensorAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorAdd) | None
-| [mindspore.ops.operations.RealDiv](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RealDiv) | None
-| [mindspore.ops.operations.Mul](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mul) | None
-| [mindspore.ops.operations.Sub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sub) | None
-| [mindspore.ops.operations.Pow](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pow) | None
-| [mindspore.ops.operations.FloorDiv](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorDiv) | None
-| [mindspore.ops.operations.Greater](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Greater) | None
-| [mindspore.ops.operations.AssignSub](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignSub) | None
-| [mindspore.ops.operations.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SigmoidCrossEntropyWithLogits) | None
-| [mindspore.ops.operations.Equal](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Equal) | None
-| [mindspore.ops.operations.NotEqual](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NotEqual) | None
-| [mindspore.ops.operations.Maximum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Maximum) | None
-| [mindspore.ops.operations.Minimum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Minimum) | None
-| [mindspore.ops.operations.BiasAdd](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BiasAdd) | None
-| [mindspore.ops.operations.Concat](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Concat) | The input_x can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
-| [mindspore.ops.operations.DropoutGenMask](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutGenMask) | Need to be used in conjunction with `DropoutDoMask`.
-| [mindspore.ops.operations.DropoutDoMask](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutDoMask) | Need to be used in conjunction with `DropoutGenMask`，configuring shard strategy is not supported.
-| [mindspore.ops.operations.GatherV2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherV2) | Only support 1-dim and 2-dim parameters and the last dimension of the input_params should be 32-byte aligned; Scalar input_indices is not supported; Repeated calculation is not supported when the parameters are split in the dimension of the axis; Split input_indices and input_params at the same time is not supported.
-| [mindspore.ops.operations.SparseGatherV2](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseGatherV2) | The same as GatherV2.
-| [mindspore.ops.operations.EmbeddingLookup](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.EmbeddingLookup) | The same as GatherV2.
-| [mindspore.ops.operations.L2Normalize](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.L2Normalize) | The input_x can't be split into the dimension of axis, otherwise it's inconsistent with the single machine in the mathematical logic.
-| [mindspore.ops.operations.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SoftmaxCrossEntropyWithLogits) | The last dimension of logits and labels can't be splited; Only supports using output[0].
-| [mindspore.ops.operations.MatMul](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MatMul) | `transpose_a=True` is not supported.
-| [mindspore.ops.operations.BatchMatMul](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchMatMul) | `transpore_a=True` is not supported.
-| [mindspore.ops.operations.PReLU](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.PReLU) | The shard strategy in channel dimension of input_x should be consistent with weight.
-| [mindspore.ops.operations.OneHot](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OneHot) | Only support 1-dim indices.
-| [mindspore.ops.operations.ReduceSum](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceSum) | None
-| [mindspore.ops.operations.ReduceMax](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMax) | None
-| [mindspore.ops.operations.ReduceMin](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMin) | None
-| [mindspore.ops.operations.ArgMinWithValue](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMinWithValue) | The output index can't be used as the input of other operators.
-| [mindspore.ops.operations.ArgMaxWithValue](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMaxWithValue) | The output index can't be used as the input of other operators.
-| [mindspore.ops.operations.ReduceMean](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMean) | None
-| [mindspore.ops.operations.Reshape](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reshape) | Configuring shard strategy is not supported.
-| [mindspore.ops.operations.StridedSlice](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.StridedSlice) | Only support mask with all 0 values; The dimension needs to be split should be all extracted; Split is not supported when the strides of dimension is 1.
-| [mindspore.ops.operations.Tile](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tile) | Only support configuring shard strategy for multiples.
-| [mindspore.ops.operations.Transpose](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Transpose) | None
-| [mindspore.ops.operations.Diag](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Diag) | Configuring shard strategy is not supported.
-
-> Repeated calculation means that the device is not fully used. For example, the cluster has 8 devices to run distributed training, the splitting strategy only cuts the input into 4 copies. In this case, double counting will occur.
->
-
-## Implicit Type Conversion
-
-### conversion rules
-* Scalar and Tensor operations: during operation, the scalar is automatically converted to Tensor, and the data type is consistent with the Tensor data type involved in the operation;
-when Tensor is a bool data type and the scalar is int or float, both the scalar and Tensor are converted to the Tensor with the data type of int32 or float32.
-* Tensor operation of different data types: the priority of data type is bool < uint8 < int8 < int16 < int32 < int64 < float16 < float32
-
-## 安装类
-
-### pip安装
-
-Q：安装MindSpore版本：GPU、CUDA 10.1、0.5.0-beta、Ubuntu-x86，出现问题：`cannot open shared object file:file such file or directory`。
-
-A：从报错情况来看，是cublas库没有找到。一般的情况下是cublas库没有安装，或者是因为没有加入到环境变量中去。通常cublas是随着cuda以及驱动一起安装的，确认安装后把cublas所在的目录加入`LD_LIBRARY_PATH`环境变量中即可。
-
-
-
-## Model Zoo
-
-| 领域 | 子领域 | 网络 | Ascend | GPU | CPU
-|:---- |:------- |:---- |:---- |:---- |:----
-|计算机视觉（CV） | 图像分类（Image Classification） | [AlexNet](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/alexnet/src/alexnet.py) | Supported | Supported | Doing
-| 计算机视觉（CV） | 图像分类（Image Classification） | [GoogleNet](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/googlenet/src/googlenet.py) | Supported | Doing | Doing
-| 计算机视觉（CV） | 图像分类（Image Classification） | [LeNet](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/lenet/src/lenet.py) | Supported | Supported | Supported
-| 计算机视觉（CV） | 图像分类（Image Classification） | [ResNet-50](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnet/src/resnet.py) | Supported | Supported | Doing
-|计算机视觉（CV） | 图像分类（Image Classification） | [ResNet-101](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnet/src/resnet.py) | Supported |Doing | Doing
-|计算机视觉（CV） | 图像分类（Image Classification） | [SE-ResNet50](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnet/src/resnet.py) | Supported |Doing | Doing
-|计算机视觉（CV） | 图像分类（Image Classification） | [ResNext50](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/resnext50/src/image_classification.py) | Supported | Supported | Doing
-| 计算机视觉（CV） | 图像分类（Image Classification） | [VGG16](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/vgg16/src/vgg.py) | Supported | Doing | Doing
-| 计算机视觉（CV） | 图像分类（Image Classification） | [InceptionV3](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/inceptionv3/src/inception_v3.py) | Supported | Doing | Doing
-| 计算机视觉（CV） | 移动端图像分类（Mobile Image Classification）
-
-## mindspore.nn
-
-| 操作名 | Ascend | GPU | CPU |算子类别
-| :----------- |:------ |:------ |:-----|:---
-| [mindspore.nn.Softmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Softmax) | Supported | Supported | Supported |layer/activation
-| [mindspore.nn.LogSoftmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LogSoftmax) | Supported | Supported | Doing |layer/activation
-| [mindspore.nn.ReLU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ReLU) | Supported | Supported | Supported |layer/activation
-| [mindspore.nn.ReLU6](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ReLU6) |Supported | Supported | Supported |layer/activation
-| [mindspore.nn.HSwish](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.HSwish) | Doing | Supported | Doing |layer/activation
-| [mindspore.nn.HSigmoid](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.HSigmoid) | Doing | Supported | Doing |layer/activation
-| [mindspore.nn.LeakyReLU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LeakyReLU) | Supported |Supported | Doing |layer/activation
-| [mindspore.nn.Tanh](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Tanh) | Supported | Supported | Doing |layer/activation
-| [mindspore.nn.GELU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GELU) | Supported | Supported | Doing |layer/activation
-| [mindspore.nn.Sigmoid](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Sigmoid) | Supported |Supported | Doing |layer/activation
-| [mindspore.nn.PReLU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.PReLU) | Supported |Doing | Doing |layer/activation
-| [mindspore.nn.Dropout](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Dropout) |Supported | Supported | Supported |layer/basic
-| [mindspore.nn.Flatten](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Flatten) |Supported | Supported | Supported |layer/basic
-| [mindspore.nn.Dense](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Dense) |Supported | Supported | Supported |layer/basic
-| [mindspore.nn.ClipByNorm](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ClipByNorm) |Supported | Supported | Doing |layer/basic
-| [mindspore.nn.Norm](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Norm) |Doing | Supported | Doing |layer/basic
-| [mindspore.nn.OneHot](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.OneHot) | Supported | Supported | Supported |layer/basic
-| [mindspore.nn.Range](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Range) | Supported | Doing | Doing |layer/basic
-| [mindspore.nn.SequentialCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SequentialCell) |Supported | Supported | Doing |layer/container
-| [mindspore.nn.CellList](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CellList) | Supported | Supported | Doing |layer/container
-| [mindspore.nn.Conv2d](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv2d) | Supported | Supported | Supported |layer/conv
-| [mindspore.nn.Conv2dTranspose](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv2dTranspose) | Supported | Supported | Doing |layer/conv
-| [mindspore.nn.Conv1d](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv1d) | Supported | Supported | Doing |layer/conv
-| [mindspore.nn.Conv1dTranspose](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv1dTranspose) | Supported | Supported | Doing |layer/conv
-| [mindspore.nn.Embedding](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Embedding) |Supported | Supported | Doing |layer/embedding
-| [mindspore.nn.ImageGradients](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ImageGradients) | Supported |Supported | Doing |layer/image
-| [mindspore.nn.SSIM](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SSIM) | Supported | Supported | Doing |layer/image
-| [mindspore.nn.PSNR](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.PSNR) | Supported |Doing | Doing |layer/image
-| [mindspore.nn.CentralCrop](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CentralCrop) | Supported |Doing | Doing |layer/image
-| [mindspore.nn.LSTM](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LSTM) | Doing | Supported | Supported |layer/lstm
-| [mindspore.nn.GlobalBatchNorm](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GlobalBatchNorm) | Supported |Doing | Doing |layer/normalization
-| [mindspore.nn.BatchNorm1d](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm1d) | Supported |Doing | Doing |layer/normalization
-| [mindspore.nn.BatchNorm2d](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.BatchNorm2d) | Supported | Supported | Doing |layer/normalization
-| [mindspore.nn.GroupNorm](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GroupNorm) | Supported | Doing | Doing |layer/normalization
-| [mindspore.nn.LayerNorm](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LayerNorm) | Supported | Supported | Doing |layer/normalization
-| [mindspore.nn.MatrixDiag](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiag) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.MatrixDiagPart](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MatrixDiagPart) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.MatrixSetDiag](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MatrixSetDiag) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.LinSpace](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LinSpace) | Supported | Doing | Doing | layer/normalization
-| [mindspore.nn.MaxPool2d](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MaxPool2d) | Supported | Supported | Supported |layer/pooling
-| [mindspore.nn.AvgPool2d](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.AvgPool2d) | Supported | Supported | Doing |layer/pooling
-| [mindspore.nn.DenseBnAct](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DenseBnAct) |Supported | Doing | Doing |layer/quant
-| [mindspore.nn.Conv2dBnAct](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Conv2dBnAct) | Supported | Supported | Doing |layer/quant
-| [mindspore.nn.L1Loss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.L1Loss) |Supported |Supported | Doing |loss/loss
-| [mindspore.nn.MSELoss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MSELoss) | Supported |Doing | Doing |loss/loss
-| [mindspore.nn.SmoothL1Loss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SmoothL1Loss) | Supported |Doing | Doing |loss/loss
-| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits) | Supported | Supported | Supported |loss/loss
-| [mindspore.nn.SoftmaxCrossEntropyExpand](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyExpand) | Supported |Supported | Doing |loss/loss
-| [mindspore.nn.CosineEmbeddingLoss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CosineEmbeddingLoss) |Supported |Supported | Doing |loss/loss
-| [mindspore.nn.ProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ProximalAdagrad) | Supported |Doing | Doing |optim/ProximalAdagrad
-| [mindspore.nn.LazyAdam](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LazyAdam) | Supported |Doing | Doing |optim/lazyadam
-| [mindspore.nn.Adam](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Adam) | Supported |Doing | Doing |optim/adam
-| [mindspore.nn.AdamWeightDecay](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.AdamWeightDecay) | Supported | Supported | Doing |optim/adam
-| [mindspore.nn.Lamb](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Lamb) | Supported | Supported | Doing |optim/lamb
-| [mindspore.nn.LARS](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.LARS) |Supported |Doing | Doing |optim/lars
-| [mindspore.nn.Momentum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Momentum) | Supported | Supported | Supported |optim/momentum
-| [mindspore.nn.Optimizer](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Optimizer) | Supported | Supported | Doing |optim/optimizer
-| [mindspore.nn.RMSProp](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.RMSProp) | Supported | Supported | Doing |optim/optimizer
-| [mindspore.nn.SGD](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SGD) |Supported |Supported | Doing |optim/sgd
-| [mindspore.nn.WithLossCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.WithLossCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.WithGradCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.WithGradCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.TrainOneStepCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.DataWrapper](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DataWrapper) |Doing | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.GetNextSingleOp](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.GetNextSingleOp) |Doing | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.WithEvalCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.WithEvalCell) | Supported | Supported | Doing |wrap/cell_wrapper
-| [mindspore.nn.ParameterUpdate](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ParameterUpdate) | Supported |Doing | Doing |wrap/cell_wrapper
-| [mindspore.nn.DistributedGradReducer](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DistributedGradReducer) | Supported |Doing | Doing |wrap/grad_reducer
-| [mindspore.nn.DynamicLossScaleUpdateCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.DynamicLossScaleUpdateCell) | Doing |Doing | Doing |wrap/loss_scale
-| [mindspore.nn.FixedLossScaleUpdateCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.FixedLossScaleUpdateCell) | Doing |Doing | Doing |wrap/loss_scale
-| [mindspore.nn.TrainOneStepWithLossScaleCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.TrainOneStepWithLossScaleCell) | Doing |Doing | Doing |wrap/loss_scale
-| [mindspore.nn.Cell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.Cell) | Supported | Supported | Supported |cell
-
-## mindspore.ops.operations
-
-| 操作名 | Ascend | GPU | CPU |算子类别
-| :----------- |:------ |:------ |:-----|:---
-| [mindspore.ops.operations.Flatten](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Flatten) | Supported | Supported |Supported | nn_ops
-| [mindspore.ops.operations.Softmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softmax) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.Acosh](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Acosh) | Doing | Doing | Doing | nn_ops
-| [mindspore.ops.operations.FloorMod](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorMod) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.Elu](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Elu) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.MirrorPad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MirrorPad) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.Unpack](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Unpack) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.Pack](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pack) | Supported| Doing | Doing | nn_ops
-| [mindspore.ops.operations.L2Loss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.L2Loss) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.CTCLoss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CTCLoss) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.RNNTLoss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RNNTLoss) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.LogSoftmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogSoftmax) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Softplus](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softplus) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.ReLU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReLU) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.ReLU6](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReLU6) | Supported | Supported |Supported | nn_ops
-| [mindspore.ops.operations.HSwish](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HSwish) | Doing | Supported |Doing | nn_ops
-| [mindspore.ops.operations.HSigmoid](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HSigmoid) | Doing | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Sigmoid](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sigmoid) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Tanh](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tanh) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.BatchNorm](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchNorm) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.LRN](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LRN) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.Conv2D](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Conv2D) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.DepthwiseConv2dNative](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthwiseConv2dNative) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.DepthwiseConv2dNativeBackpropInput](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthwiseConv2dNativeBackpropInput) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.DepthwiseConv2dNativeiBackpropFilter](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthwiseConv2dNativeBackpropFilter) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.MaxPoolWithArgmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MaxPoolWithArgmax) | Supported | Doing |Doing | nn_ops
-| [mindspore.ops.operations.MaxPool](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MaxPool) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.AvgPool](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AvgPool) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.Conv2DBackpropInput](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Conv2DBackpropInput) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.BiasAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BiasAdd) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.TopK](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TopK) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SoftmaxCrossEntropyWithLogits) | Supported | Supported |Doing | nn_ops
-| [mindspore.ops.operations.SparseSoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseSoftmaxCrossEntropyWithLogits) | Doing | Supported | Supported | nn_ops
-| [mindspore.ops.operations.ApplyMomentum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyMomentum) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.ApplyAddSign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyAddSign) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyPowerSign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyPowerSign) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyGradientDescent](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyGradientDescent) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyProximalGradientDescent](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyProximalGradientDescent) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ApplyRMSProp](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyRMSProp) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.ApplyCenteredRMSProp](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyCenteredRMSProp) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.SparseApplyAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyAdagrad) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.SparseApplyAdagradV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyAdagradV2) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.SparseApplyProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.FusedSparseProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseProximalAdagrad) | Doing | Doing | Supported | nn_ops
-| [mindspore.ops.operations.ApplyProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyProximalAdagrad) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.FusedSparseLazyAdam](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseLazyAdam) | Doing | Doing | Supported | nn_ops
-| [mindspore.ops.operations.FusedSparseAdam](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseAdam) | Doing | Doing | Supported | nn_ops
-| [mindspore.ops.operations.SmoothL1Loss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SmoothL1Loss) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.SGD](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SGD) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.LayerNorm](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LayerNorm) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.L2Normalize](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.L2Normalize) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.DropoutGenMask](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutGenMask) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.DropoutDoMask](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutDoMask) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.ResizeBilinear](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ResizeBilinear) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.OneHot](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OneHot) | Supported | Supported | Supported | nn_ops
-| [mindspore.ops.operations.Gelu](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Gelu) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.GetNext](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GetNext) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.PReLU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.PReLU) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.LSTM](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LSTM) | Doing | Supported | Supported | nn_ops
-| [mindspore.ops.operations.BasicLSTMCell](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BasicLSTMCell) | Doing | Doing | Doing | nn_ops
-| [mindspore.ops.operations.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SigmoidCrossEntropyWithLogits) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.Pad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pad) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.ROIAlign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ROIAlign) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.Adam](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Adam) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.BinaryCrossEntropy](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BinaryCrossEntropy) | Supported | Supported | Doing | nn_ops
-| [mindspore.ops.operations.KLDivLoss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.KLDivLoss) | Doing | Supported | Doing | nn_ops
-| [mindspore.ops.operations.LARSUpdate](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LARSUpdate) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.Softsign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softsign) | Supported | Doing | Doing | nn_ops
-| [mindspore.ops.operations.TensorAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorAdd) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.AssignAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignAdd) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.AssignSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignSub) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ReduceMean](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMean) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.ReduceSum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceSum) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.ReduceAll](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceAll) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ReduceMax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMax) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.ReduceMin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMin) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.ReduceProd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceProd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.CumProd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CumProd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.MatMul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MatMul) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.BatchMatMul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchMatMul) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.CumSum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CumSum) | Supported | Supported| Doing | math_ops
-| [mindspore.ops.operations.AddN](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AddN) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.Neg](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Neg) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Sub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sub) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.Mul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mul) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.Square](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Square) | Supported | Supported | Supported | math_ops
-| [mindspore.ops.operations.SquareSumAll](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SquareSumAll) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Rsqrt](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rsqrt) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Sqrt](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sqrt) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Reciprocal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reciprocal) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Pow](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pow) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Exp](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Exp) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Log](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Log) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Log1p](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Log1p) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Minimum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Minimum) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Maximum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Maximum) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.RealDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RealDiv) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Div](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Div) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.DivNoNan](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DivNoNan) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.FloorDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorDiv) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Floor](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Floor) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Equal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Equal) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.EqualCount](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.EqualCount) | Doing | Supported | Supported | math_ops
-| [mindspore.ops.operations.NotEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NotEqual) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Greater](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Greater) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.GreaterEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GreaterEqual) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Less](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Less) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Atan2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Atan2) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.LessEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LessEqual) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.LogicalNot](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalNot) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.LogicalAnd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalAnd) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.LogicalOr](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalOr) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.BitwiseAnd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseAnd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BitwiseOr](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseOr) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BitwiseXor](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseXor) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Ceil](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Ceil) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Inv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Inv) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Invert](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Invert) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NPUAllocFloatStatus](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NPUAllocFloatStatus) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NPUGetFloatStatus](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NPUGetFloatStatus) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NPUClearFloatStatus](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NPUClearFloatStatus) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.FloatStatus](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloatStatus) | Doing | Supported | Doing | math_ops
-| [mindspore.ops.operations.Cos](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cos) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Cosh](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cosh) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ACos](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ACos) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BesselI0e](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BesselI0e) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.BesselI1e](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BesselI1e) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.TruncateDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncateDiv) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.TruncateMod](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncateMod) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Tan](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tan) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Asin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Asin) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Asinh](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Asinh) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Erf](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Erf) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Erfc](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Erfc) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Sin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sin) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Sinh](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sinh) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Expm1](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Expm1) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.NMSWithMask](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NMSWithMask) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Abs](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Abs) | Supported | Supported | Doing | math_ops
-| [mindspore.ops.operations.Sign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sign) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Round](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Round) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ApproximateEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApproximateEqual) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.InplaceAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InplaceAdd) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.InplaceSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InplaceSub) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Mod](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mod) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.ExpandDims](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ExpandDims) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.DType](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DType) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.SameTypeShape](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SameTypeShape) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Cast](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cast) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.IsSubClass](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IsSubClass) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.IsInstance](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IsInstance) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Reshape](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reshape) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Shape](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Shape) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Squeeze](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Squeeze) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.Transpose](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Transpose) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.GatherV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherV2) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Split](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Split) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.Rank](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rank) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.TruncatedNormal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncatedNormal) | Doing | Doing | Doing | array_ops
-| [mindspore.ops.operations.Size](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Size) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Fill](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Fill) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.OnesLike](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OnesLike) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ZerosLike](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ZerosLike) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.TupleToArray](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TupleToArray) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ScalarToArray](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarToArray) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ScalarToTensor](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarToTensor) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.InvertPermutation](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InvertPermutation) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Argmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Argmax) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Argmin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Argmin) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ArgMaxWithValue](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMaxWithValue) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ArgMinWithValue](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMinWithValue) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Tile](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tile) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.UnsortedSegmentSum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UnsortedSegmentSum) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.UnsortedSegmentMin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UnsortedSegmentMin) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.UnsortedSegmentProd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UnsortedSegmentProd) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Concat](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Concat) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ParallelConcat](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ParallelConcat) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Slice](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Slice) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Select](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Select) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.StridedSlice](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.StridedSlice) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.Diag](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Diag) | Doing | Doing | Doing | array_ops
-| [mindspore.ops.operations.DiagPart](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DiagPart) | Doing | Doing | Doing | array_ops
-| [mindspore.ops.operations.Eye](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Eye) | Supported | Supported | Supported | array_ops
-| [mindspore.ops.operations.ScatterNd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNd) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ResizeNearestNeighbor](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ResizeNearestNeighbor) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.GatherNd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherNd) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.ApplyFtrl](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyFtrl) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.SparseApplyFtrl](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyFtrl) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.FusedSparseFtrl](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseFtrl) | Doing | Doing | Supported | array_ops
-| [mindspore.ops.operations.SparseApplyFtrlV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyFtrlV2) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNdUpdate](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdUpdate) | Supported | Doing | Supported | array_ops
-| [mindspore.ops.operations.ScatterUpdate](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterUpdate) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterMul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMul) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterDiv) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.SpaceToDepth](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SpaceToDepth) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.DepthToSpace](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DepthToSpace) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.SpaceToBatch](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SpaceToBatch) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.SpaceToBatchND](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SpaceToBatchND) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.BatchToSpace](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchToSpace) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.BatchToSpaceND](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchToSpaceND) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.IsFinite](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IsFinite) | Supported | Supported | Doing | array_ops
-| [mindspore.ops.operations.InplaceUpdate](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InplaceUpdate) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterSub) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterMax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMax) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterMin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMin) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNdAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdAdd) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNdSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdSub) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ScatterNonAliasingAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNonAliasingAdd) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.Rint](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rint) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ReverseV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReverseV2) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.ReduceOp](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceOp) | Supported | Supported | Doing | comm_ops
-| [mindspore.ops.operations.AllReduce](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AllReduce) | Supported | Supported | Doing | comm_ops
-| [mindspore.ops.operations.AllGather](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AllGather) | Supported | Supported | Doing | comm_ops
-| [mindspore.ops.operations.ReduceScatter](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceScatter) | Doing | Supported | Doing | comm_ops
-| [mindspore.ops.operations.Broadcast](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Broadcast) | Supported | Doing | Doing | comm_ops
-| [mindspore.ops.operations.ControlDepend](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ControlDepend) | Supported | Supported | Supported | control_ops
-| [mindspore.ops.operations.GeSwitch](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GeSwitch) | Doing | Doing | Doing | control_ops
-| [mindspore.ops.operations.Merge](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Merge) | Doing | Doing | Doing | control_ops
-| [mindspore.ops.operations.ScalarSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.ImageSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ImageSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.TensorSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.HistogramSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HistogramSummary) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.InsertGradientOf](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InsertGradientOf) | Supported | Supported | Supported | debug_ops
-| [mindspore.ops.operations.Print](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Print) | Supported | Doing | Doing | debug_ops
-| [mindspore.ops.operations.Assign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Assign) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.BoundingBoxEncode](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BoundingBoxEncode) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.BoundingBoxDecode](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BoundingBoxDecode) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.PopulationCount](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.PopulationCount) | Supported | Doing | Doing | other_ops
-| [mindspore.ops.operations.CheckValid](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CheckValid) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.IOU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.IOU) | Supported | Supported | Doing | other_ops
-| [mindspore.ops.operations.MakeRefKey](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MakeRefKey) | Supported | Supported | Supported | other_ops
-| [mindspore.ops.operations.InTopK](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.InTopK) | Supported | Doing | Doing | other_ops
-| [mindspore.ops.operations.StandardNormal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.StandardNormal) | Supported | Supported | Doing | random_ops
-| [mindspore.ops.operations.Gamma](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Gamma) | Supported | Doing | Doing | random_ops
-| [mindspore.ops.operations.Poisson](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Poisson) | Supported | Doing | Doing | random_ops
-| [mindspore.ops.operations.UniformInt](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UniformInt) | Supported | Supported | Doing | random_ops
-| [mindspore.ops.operations.UniformReal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.UniformReal) | Supported | Supported | Doing | random_ops
-| [mindspore.ops.operations.RandomChoiceWithMask](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RandomChoiceWithMask) | Doing| Supported | Doing | random_ops
-| [mindspore.ops.operations.RandomCategorical](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RandomCategorical) | Supported| Doing | Doing | random_ops
-| [mindspore.ops.operations.ScalarCast](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScalarCast) | Supported | Supported | Supported | inner_ops
-| [mindspore.ops.operations.ReverseSequence](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReverseSequence) | Supported | Doing | Doing | array_ops
-| [mindspore.ops.operations.CropAndResize](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.CropAndResize) | Supported | Doing | Doing | image_ops
-| [mindspore.ops.operations.SquaredDifference](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SquaredDifference) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Xdivy](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Xdivy) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.Xlogy](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Xlogy) | Supported | Doing | Doing | math_ops
-| [mindspore.ops.operations.HistogramFixedWidth](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.HistogramFixedWidth) | Supported | Doing | Doing | math_ops
-
-## mindspore.ops.functional
-
-| 操作名 | 对应functional算子
-| :----------- | :-----------
-| [mindspore.ops.operations.Pack](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pack) | pack
-| [mindspore.ops.operations.TensorAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorAdd) | tensor_add
-| [mindspore.ops.operations.AssignSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignSub) | assign_sub
-| [mindspore.ops.operations.AddN](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AddN) | addn
-| [mindspore.ops.operations.Square](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Square) | square
-| [mindspore.ops.operations.Sqrt](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sqrt) | sqrt
-| [mindspore.ops.operations.Equal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Equal) | equal
-| [mindspore.ops.operations.NotEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NotEqual) | not_equal
-| [mindspore.ops.operations.LogicalNot](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalNot) | logical_not
-| [mindspore.ops.operations.LogicalAnd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalAnd) | logical_and
-| [mindspore.ops.operations.LogicalOr](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalOr) | logical_or
-| [mindspore.ops.operations.ExpandDims](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ExpandDims) | expand_dims
-| [mindspore.ops.operations.DType](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DType) | dtype
-| [mindspore.ops.operations.Cast](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cast) | cast
-| [mindspore.ops.operations.Reshape](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reshape) | reshape
-| [mindspore.ops.operations.Shape](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Shape) | shape
-| [mindspore.ops.operations.GatherV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherV2) | gather
-| [mindspore.ops.operations.Rank](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Rank) | rank
-| [mindspore.ops.operations.Size](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Size) | size
-| [mindspore.ops.operations.Fill](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Fill) | fill
-| [mindspore.ops.operations.OnesLike](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OnesLike) | ones_like
-| [mindspore.ops.operations.Tile](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tile) | tile
-| [mindspore.ops.operations.Select](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Select) | select
-| [mindspore.ops.operations.ScatterNd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNd) | scatter_nd
-| [mindspore.ops.operations.GatherNd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherNd) | gather_nd
-| [mindspore.ops.operations.ControlDepend](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ControlDepend) | control_depend
-| [mindspore.ops.operations.Print](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Print) | print
-| [mindspore.ops.operations.Assign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Assign) | assign
-| [mindspore.ops.operations.Pow](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pow) | tensor_pow
-
-> 当前functional支持了一部分没有属性的算子，后续会进一步补齐完整。
-
-## 分布式算子
-
-| 操作名 | 约束
-| :----------- | :-----------
-| [mindspore.ops.operations.ACos](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ACos) | None
-| [mindspore.ops.operations.Cos](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cos) | None
-| [mindspore.ops.operations.LogicalNot](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalNot) | None
-| [mindspore.ops.operations.Log](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Log) | None
-| [mindspore.ops.operations.Exp](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Exp) | None
-| [mindspore.ops.operations.LogSoftmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogSoftmax) | 输入（logits）在轴（axis）对应的维度不可切分，切分后，在数学逻辑上和单机不等价
-| [mindspore.ops.operations.Softmax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Softmax) | 输入（logits）在轴（axis）对应的维度不可切分，切分后，在数学逻辑上和单机不等价
-| [mindspore.ops.operations.Tanh](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tanh) | None
-| [mindspore.ops.operations.Gelu](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Gelu) | None
-| [mindspore.ops.operations.ReLU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReLU) | None
-| [mindspore.ops.operations.Sqrt](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sqrt) | None
-| [mindspore.ops.operations.Cast](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Cast) | None
-| [mindspore.ops.operations.Neg](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Neg) | None
-| [mindspore.ops.operations.ExpandDims](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ExpandDims) | None
-| [mindspore.ops.operations.Squeeze](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Squeeze) | None
-| [mindspore.ops.operations.Square](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Square) | None
-| [mindspore.ops.operations.Sigmoid](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sigmoid) | None
-| [mindspore.ops.operations.Dropout](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Dropout) | 不支持重复计算
-| [mindspore.ops.operations.Div](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Div) | None
-| [mindspore.ops.operations.TensorAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorAdd) | None
-| [mindspore.ops.operations.RealDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RealDiv) | None
-| [mindspore.ops.operations.Mul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mul) | None
-| [mindspore.ops.operations.Sub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sub) | None
-| [mindspore.ops.operations.Pow](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pow) | None
-| [mindspore.ops.operations.FloorDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorDiv) | None
-| [mindspore.ops.operations.Greater](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Greater) | None
-| [mindspore.ops.operations.AssignSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignSub) | None
-| [mindspore.ops.operations.SigmoidCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SigmoidCrossEntropyWithLogits) | None
-| [mindspore.ops.operations.Equal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Equal) | None
-| [mindspore.ops.operations.NotEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NotEqual) | None
-| [mindspore.ops.operations.Maximum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Maximum) | None
-| [mindspore.ops.operations.Minimum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Minimum) | None
-| [mindspore.ops.operations.BiasAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BiasAdd) | None
-| [mindspore.ops.operations.Concat](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Concat) | 输入（input_x）在轴（axis）所对应的维度不能切分，切分后，在数学逻辑上和单机不等价
-| [mindspore.ops.operations.DropoutGenMask](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutGenMask) | 需和`DropoutDoMask`联合使用
-| [mindspore.ops.operations.DropoutDoMask](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DropoutDoMask) | 需和`DropoutGenMask`联合使用，不支持配置切分策略
-| [mindspore.ops.operations.GatherV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GatherV2) | 仅支持1维和2维的input_params，并且input_params的最后一维要32字节对齐（出于性能考虑）；不支持标量input_indices；参数在轴（axis）所在维度切分时，不支持重复计算；不支持input_indices和input_params同时进行切分
-| [mindspore.ops.operations.SparseGatherV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseGatherV2) | 同GatherV2
-| [mindspore.ops.operations.EmbeddingLookup](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.EmbeddingLookup) | 同GatherV2
-| [mindspore.ops.operations.L2Normalize](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.L2Normalize) | 输入（input_x）在轴（axis）对应的维度不能切，切分后，在数学逻辑上和单机不等价
-| [mindspore.ops.operations.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SoftmaxCrossEntropyWithLogits) | 输入（logits、labels）的最后一维不能切分；有两个输出，正向的loss只支持取[0]
-| [mindspore.ops.operations.MatMul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.MatMul) | 不支持`transpose_a=True`
-| [mindspore.ops.operations.BatchMatMul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BatchMatMul) | 不支持`transpore_a=True`
-| [mindspore.ops.operations.PReLU](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.PReLU) | 输入（input_x）的Channel维要和weight的切分方式一致
-| [mindspore.ops.operations.OneHot](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.OneHot) | 仅支持输入（indices）是1维的Tensor
-| [mindspore.ops.operations.ReduceSum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceSum) | None
-| [mindspore.ops.operations.ReduceMax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMax) | None
-| [mindspore.ops.operations.ReduceMin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMin) | None
-| [mindspore.ops.operations.ArgMinWithValue](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMinWithValue) | 第一个输出(index)不能作为其他算子的输入
-| [mindspore.ops.operations.ArgMaxWithValue](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ArgMaxWithValue) | 第一个输出(index)不能作为其他算子的输入
-| [mindspore.ops.operations.ReduceMean](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ReduceMean) | None
-| [mindspore.ops.operations.Reshape](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Reshape) | 不支持配置切分策略
-| [mindspore.ops.operations.StridedSlice](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.StridedSlice) | 仅支持值为全0的mask；需要切分的维度必须全部提取；输入在strides不为1对应的维度不支持切分
-| [mindspore.ops.operations.Tile](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Tile) | 仅支持对multiples配置切分策略
-| [mindspore.ops.operations.Transpose](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Transpose) | None
-| [mindspore.ops.operations.Diag](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Diag) | 不支持配置切分策略
-
-> 重复计算是指，机器没有用满，比如：集群有8张卡跑分布式训练，切分策略只对输入切成了4份。这种情况下会发生重复计算。
-
-## 隐式类型转换
-### 转换规则
-* 标量与Tensor运算：运算时，将标量自动转为Tensor，数据类型和参与运算的Tensor数据类型保持一致；
-而当Tensor是bool数据类型，标量是int或float时，将标量和Tensor都转为数据类型为int32或float32的Tensor。
-* 不同数据类型Tensor运算：数据类型优先级排序为bool < uint8 < int8 < int16 < int32 < int64 < float16 < float32 < float64，
-运算时，先确定参与运算的Tensor中优先级相对最高的数据类型，然后将低优先级数据类型Tensor转换为相对最高优先级数据类型；
-而当int8和uint8数据类型的Tensor进行运算时，将其都转为int16的Tensor。
-* 不支持对Parameter进行数据类型转换：如果按照转换规则推导，需要对网络中定义的Parameter进行数据类型转换时，会抛出RuntimeError异常。
-
-### 参与转换的数据类型
-* bool
-* int8
-* uint8
-* int16
-* int32
-* int64
-* float16
-* float32
-* float64
-
-### 支持算子
-
-| 算子名
-| :-----------
-| [mindspore.ops.operations.Assign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Assign)
-| [mindspore.ops.operations.AssignSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.AssignSub)
-| [mindspore.ops.operations.ApplyMomentum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyMomentum)
-| [mindspore.ops.operations.FusedSparseAdam](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseAdam)
-| [mindspore.ops.operations.FusedSparseLazyAdam](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseLazyAdam)
-| [mindspore.ops.operations.FusedSparseFtrl](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseFtrl)
-| [mindspore.ops.operations.FusedSparseProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FusedSparseProximalAdagrad)
-| [mindspore.ops.operations.ApplyAdaMax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyAdaMax)
-| [mindspore.ops.operations.ApplyAdadelta](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyAdadelta)
-| [mindspore.ops.operations.ApplyAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyAdagrad)
-| [mindspore.ops.operations.ApplyAdagradV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyAdagradV2)
-| [mindspore.ops.operations.SparseApplyAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyAdagrad)
-| [mindspore.ops.operations.SparseApplyAdagradV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyAdagradV2)
-| [mindspore.ops.operations.ApplyProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyProximalAdagrad)
-| [mindspore.ops.operations.SparseApplyProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyProximalAdagrad)
-| [mindspore.ops.operations.ApplyAddSign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyAddSign)
-| [mindspore.ops.operations.ApplyPowerSign](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyPowerSign)
-| [mindspore.ops.operations.ApplyGradientDescent](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyGradientDescent)
-| [mindspore.ops.operations.ApplyProximalGradientDescent](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApplyProximalGradientDescent)
-| [mindspore.ops.operations.SparseApplyFtrl](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyFtrl)
-| [mindspore.ops.operations.SparseApplyFtrlV2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SparseApplyFtrlV2)
-| [mindspore.ops.operations.BitwiseAnd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseAnd)
-| [mindspore.ops.operations.BitwiseOr](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseOr)
-| [mindspore.ops.operations.BitwiseXor](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.BitwiseXor)
-| [mindspore.ops.operations.TensorAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TensorAdd)
-| [mindspore.ops.operations.Sub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Sub)
-| [mindspore.ops.operations.Mul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mul)
-| [mindspore.ops.operations.Pow](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Pow)
-| [mindspore.ops.operations.Minimum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Minimum)
-| [mindspore.ops.operations.Maximum](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Maximum)
-| [mindspore.ops.operations.RealDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.RealDiv)
-| [mindspore.ops.operations.Div](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Div)
-| [mindspore.ops.operations.DivNoNan](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.DivNoNan)
-| [mindspore.ops.operations.FloorDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorDiv)
-| [mindspore.ops.operations.TruncateDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncateDiv)
-| [mindspore.ops.operations.TruncateMod](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.TruncateMod)
-| [mindspore.ops.operations.Mod](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Mod)
-| [mindspore.ops.operations.FloorMod](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.FloorMod)
-| [mindspore.ops.operations.Atan2](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Atan2)
-| [mindspore.ops.operations.SquaredDifference](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.SquaredDifference)
-| [mindspore.ops.operations.Xdivy](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Xdivy)
-| [mindspore.ops.operations.Xlogy](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Xlogy)
-| [mindspore.ops.operations.Equal](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Equal)
-| [mindspore.ops.operations.ApproximateEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ApproximateEqual)
-| [mindspore.ops.operations.NotEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.NotEqual)
-| [mindspore.ops.operations.Greater](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Greater)
-| [mindspore.ops.operations.GreaterEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.GreaterEqual)
-| [mindspore.ops.operations.Less](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.Less)
-| [mindspore.ops.operations.LessEqual](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LessEqual)
-| [mindspore.ops.operations.LogicalAnd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalAnd)
-| [mindspore.ops.operations.LogicalOr](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.LogicalOr)
-| [mindspore.ops.operations.ScatterNdUpdate](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdUpdate)
-| [mindspore.ops.operations.ScatterNdAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdAdd)
-| [mindspore.ops.operations.ScatterNdSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNdSub)
-| [mindspore.ops.operations.ScatterNonAliasingAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterNonAliasingAdd)
-| [mindspore.ops.operations.ScatterUpdate](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterUpdate)
-| [mindspore.ops.operations.ScatterMax](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMax)
-| [mindspore.ops.operations.ScatterMin](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMin)
-| [mindspore.ops.operations.ScatterAdd](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterAdd)
-| [mindspore.ops.operations.ScatterSub](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterSub)
-| [mindspore.ops.operations.ScatterMul](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterMul)
-| [mindspore.ops.operations.ScatterDiv](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html#mindspore.ops.operations.ScatterDiv)
-
diff --git a/install/mindspore_cpu_install.md b/install/bak/mindspore_cpu_install.md
similarity index 62%
rename from install/mindspore_cpu_install.md
rename to install/bak/mindspore_cpu_install.md
index ed91ce11ce44ee64ac32238221bd668cba923657..17a0d7559e885f62c721bd7785a752caa74f0d16 100644
--- a/install/mindspore_cpu_install.md
+++ b/install/bak/mindspore_cpu_install.md
@@ -11,20 +11,27 @@
- [安装指南](#安装指南)
- [通过可执行文件安装](#通过可执行文件安装)
- [从源码编译安装](#从源码编译安装)
+ - [版本升级](#版本升级)
- [安装MindArmour](#安装mindarmour)
- [安装MindSpore Hub](#安装mindspore-hub)
+
+
+本文档介绍如何在CPU环境的Ubuntu系统上快速安装MindSpore。
+
## 环境要求
### 系统要求和软件依赖
| 版本号 | 操作系统 | 可执行文件安装依赖 | 源码编译安装依赖 |
| ---- | :--- | :--- | :--- |
-| MindSpore master | - Ubuntu 18.04 x86_64
+
+This document describes how to quickly install MindSpore in a Ubuntu system with a CPU environment.
+
## Environment Requirements
### System Requirements and Software Dependencies
| Version | Operating System | Executable File Installation Dependencies | Source Code Compilation and Installation Dependencies |
| ---- | :--- | :--- | :--- |
-| MindSpore master | - Ubuntu 18.04 x86_64
+
+本文档介绍如何在CPU环境的Windows系统上快速安装MindSpore。
+
## 环境要求
### 系统要求和软件依赖
| 版本号 | 操作系统 | 可执行文件安装依赖 | 源码编译安装依赖 |
| ---- | :--- | :--- | :--- |
-| MindSpore master | Windows 10 x86_64 | - [Python](https://www.python.org/downloads/) 3.7.5
+
## Environment Requirements
### System Requirements and Software Dependencies
| Version | Operating System | Executable File Installation Dependencies | Source Code Compilation and Installation Dependencies |
| ---- | :--- | :--- | :--- |
-| MindSpore master | Windows 10 x86_64 | - [Python](https://www.python.org/downloads/) 3.7.5
+
+本文档介绍如何在Ascend AI处理器的环境上快速安装MindSpore。
+
## 环境要求
### 硬件要求
@@ -33,10 +38,12 @@
| 版本号 | 操作系统 | 可执行文件安装依赖 | 源码编译安装依赖 |
| ---- | :--- | :--- | :--- |
-| MindSpore master | - Ubuntu 18.04 aarch64
+
+This document describes how to quickly install MindSpore in an Ascend AI processor environment.
+
## Environment Requirements
### Hardware Requirements
@@ -33,10 +38,12 @@ This document describes how to quickly install MindSpore in an Ascend AI process
| Version | Operating System | Executable File Installation Dependencies | Source Code Compilation and Installation Dependencies |
| ---- | :--- | :--- | :--- |
-| MindSpore master | - Ubuntu 18.04 aarch64
+
+本文档介绍如何在Nvidia GPU的环境上快速安装MindSpore。
+
## 环境要求
### 硬件要求
@@ -29,8 +34,10 @@
| 版本号 | 操作系统 | 可执行文件安装依赖 | 源码编译安装依赖 |
| ---- | :--- | :--- | :--- |
-| MindSpore master | Ubuntu 18.04 x86_64 | - [Python](https://www.python.org/downloads/) 3.7.5
+
+This document describes how to quickly install MindSpore in a NVIDIA GPU environment.
+
## Environment Requirements
### Hardware Requirements
@@ -29,8 +34,10 @@ This document describes how to quickly install MindSpore in a NVIDIA GPU environ
| Version | Operating System | Executable File Installation Dependencies | Source Code Compilation and Installation Dependencies |
| ---- | :--- | :--- | :--- |
-| MindSpore master | Ubuntu 18.04 x86_64 | - [Python](https://www.python.org/downloads/) 3.7.5
+
+本文档介绍如何在Ascend 910环境的Linux系统上，使用Conda方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04/CentOS 7.6/EulerOS 2.8是64位操作系统。
+- 确认安装Ascend 910 AI处理器软件配套包（Atlas Data Center Solution V100R020C10：[A800-9000 1.0.8 (aarch64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9000-pid-250702818/software/252069004?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702818)，[A800-9010 1.0.8 (x86_64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9010-pid-250702809/software/252062130?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702809)，[CANN V100R020C10](https://support.huawei.com/enterprise/zh/ascend-computing/cann-pid-251168373/software/251174283?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C251168373)）。
+ - 确认当前用户有权限访问Ascend 910 AI处理器配套软件包的安装路径`/usr/local/Ascend`，若无权限，需要root用户将当前用户添加到`/usr/local/Ascend`所在的用户组，具体配置请详见配套软件包的说明文档。
+ - 安装Ascend 910 AI处理器配套软件包提供的whl包，whl包随配套软件包发布，升级配套软件包之后需要重新安装。
+
+ ```bash
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/topi-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/te-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/hccl-{version}-py3-none-any.whl
+ ```
+
+## 安装Conda
+
+下载并安装对应架构的Conda安装包。
+
+- X86架构
+ - 官网下载地址：[X86 Anaconda](https://www.anaconda.com/distribution/) 或 [X86 Miniconda](https://docs.conda.io/en/latest/miniconda.html)
+ - 清华镜像源下载地址：[X86 Anaconda](https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.02-Linux-x86_64.sh)
+- ARM架构
+ - [ARM Anaconda](https://github.com/Archiconda/build-tools/releases/download/0.2.3/Archiconda3-0.2.3-Linux-aarch64.sh)
+
+## 添加Conda镜像源
+
+从清华源镜像源下载Conda安装包的可跳过此步操作。
+
+```bash
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
+conda config --set show_channel_urls yes
+```
+
+## 创建并激活Conda环境
+
+```bash
+conda create -n mindspore python=3.7.5
+conda activate mindspore
+```
+
+## 安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/ascend/{system}/mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+- `{system}`表示系统，例如使用的欧拉系统ARM架构，`{system}`应写为`euleros_aarch64`，目前可支持以下系统`euleros_aarch64`/`centos_aarch64`/`centos_x86`/`ubuntu_aarch64`/`ubuntu_x86`。
+
+## 配置环境变量
+
+**如果Ascend 910 AI处理器配套软件包没有安装在默认路径**，安装好MindSpore之后，需要导出Runtime相关环境变量，下述命令中`LOCAL_ASCEND=/usr/local/Ascend`的`/usr/local/Ascend`表示配套软件包的安装路径，需注意将其改为配套软件包的实际安装路径。
+
+```bash
+# control log level. 0-DEBUG, 1-INFO, 2-WARNING, 3-ERROR, default level is WARNING.
+export GLOG_v=2
+
+# Conda environmental options
+LOCAL_ASCEND=/usr/local/Ascend # the root directory of run package
+
+# lib libraries that the run package depends on
+export LD_LIBRARY_PATH=${LOCAL_ASCEND}/add-ons/:${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/lib64:${LOCAL_ASCEND}/driver/lib64:${LOCAL_ASCEND}/opp/op_impl/built-in/ai_core/tbe/op_tiling:${LD_LIBRARY_PATH}
+
+# Environment variables that must be configured
+export TBE_IMPL_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp/op_impl/built-in/ai_core/tbe # TBE operator implementation tool path
+export ASCEND_OPP_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp # OPP path
+export PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/ccec_compiler/bin/:${PATH} # TBE operator compilation tool path
+export PYTHONPATH=${TBE_IMPL_PATH}:${PYTHONPATH} # Python library that TBE implementation depends on
+```
+
+## 验证是否成功安装
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="Ascend")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+如果输出：
+
+```text
+[[[ 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.]]]
+```
+
+说明MindSpore安装成功了。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore-ascend
+```
+
+## 安装MindInsight
+
+当您需要查看训练过程中的标量、图像、计算图以及模型超参等信息时，可以选装MindInsight。
+
+具体安装步骤参见[MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README_CN.md)。
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_ascend_install_pip.md b/install/mindspore_ascend_install_pip.md
new file mode 100644
index 0000000000000000000000000000000000000000..635d53735378d543e606fe6dfe10a5b2b06fe999
--- /dev/null
+++ b/install/mindspore_ascend_install_pip.md
@@ -0,0 +1,128 @@
+# pip方式安装MindSpore Ascend版本
+
+
+
+- [pip方式安装MindSpore Ascend版本](#pip方式安装mindspore-ascend版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [安装MindSpore](#安装mindspore)
+ - [配置环境变量](#配置环境变量)
+ - [验证是否成功安装](#验证是否成功安装)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindInsight](#安装mindinsight)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在Ascend 910环境的Linux系统上，使用pip方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04/CentOS 7.6/EulerOS 2.8是64位操作系统。
+- 确认安装[GCC 7.3.0版本](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz)。
+- 确认安装[gmp 6.1.2版本](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz)。
+- 确认安装Python 3.7.5版本。
+ - 如果未安装或者已安装其他版本的Python，可从[官网](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz)或者[华为云](https://mirrors.huaweicloud.com/python/3.7.5/Python-3.7.5.tgz)下载Python 3.7.5版本 64位，进行安装。
+- 确认安装Ascend 910 AI处理器软件配套包（Atlas Data Center Solution V100R020C10：[A800-9000 1.0.8 (aarch64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9000-pid-250702818/software/252069004?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702818), [A800-9010 1.0.8 (x86_64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9010-pid-250702809/software/252062130?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702809)，[CANN V100R020C10](https://support.huawei.com/enterprise/zh/ascend-computing/cann-pid-251168373/software/251174283?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C251168373)）。
+ - 确认当前用户有权限访问Ascend 910 AI处理器配套软件包的安装路径`/usr/local/Ascend`，若无权限，需要root用户将当前用户添加到`/usr/local/Ascend`所在的用户组，具体配置请详见配套软件包的说明文档。
+ - 安装Ascend 910 AI处理器配套软件包提供的`whl`包，`whl`包随配套软件包发布，升级配套软件包之后需要重新安装。
+
+ ```bash
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/topi-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/te-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/hccl-{version}-py3-none-any.whl
+ ```
+
+## 安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/ascend/{system}/mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+- `{system}`表示系统版本，例如使用的欧拉系统ARM架构，`{system}`应写为`euleros_aarch64`，目前Ascend版本可支持以下系统`euleros_aarch64`/`centos_aarch64`/`centos_x86`/`ubuntu_aarch64`/`ubuntu_x86`。
+
+## 配置环境变量
+
+**如果Ascend 910 AI处理器配套软件包没有安装在默认路径**，安装好MindSpore之后，需要导出Runtime相关环境变量，下述命令中`LOCAL_ASCEND=/usr/local/Ascend`的`/usr/local/Ascend`表示配套软件包的安装路径，需注意将其改为配套软件包的实际安装路径。
+
+```bash
+# control log level. 0-DEBUG, 1-INFO, 2-WARNING, 3-ERROR, default level is WARNING.
+export GLOG_v=2
+
+# Conda environmental options
+LOCAL_ASCEND=/usr/local/Ascend # the root directory of run package
+
+# lib libraries that the run package depends on
+export LD_LIBRARY_PATH=${LOCAL_ASCEND}/add-ons/:${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/lib64:${LOCAL_ASCEND}/driver/lib64:${LOCAL_ASCEND}/opp/op_impl/built-in/ai_core/tbe/op_tiling:${LD_LIBRARY_PATH}
+
+# Environment variables that must be configured
+export TBE_IMPL_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp/op_impl/built-in/ai_core/tbe # TBE operator implementation tool path
+export ASCEND_OPP_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp # OPP path
+export PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/ccec_compiler/bin/:${PATH} # TBE operator compilation tool path
+export PYTHONPATH=${TBE_IMPL_PATH}:${PYTHONPATH} # Python library that TBE implementation depends on
+```
+
+## 验证是否成功安装
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="Ascend")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+如果输出：
+
+```text
+[[[ 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.]]]
+```
+
+说明MindSpore安装成功了。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore-ascend
+```
+
+## 安装MindInsight
+
+当您需要查看训练过程中的标量、图像、计算图以及模型超参等信息时，可以选装MindInsight。
+
+具体安装步骤参见[MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README_CN.md)。
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_ascend_install_pip_en.md b/install/mindspore_ascend_install_pip_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..6307e3f1880d6b93d00a4dc83b4cbed19c89f642
--- /dev/null
+++ b/install/mindspore_ascend_install_pip_en.md
@@ -0,0 +1,131 @@
+# Installing MindSpore in Ascend by pip
+
+
+
+- [Installing MindSpore in Ascend by pip](#install-mindspore-in-ascend-by-pip)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Installing MindSpore](#installing-mindspore)
+ - [Configuring Environment Variables](#configuring-environment-variables)
+ - [Installation Verification](#insallation-verification)
+ - [Version Update](#version-update)
+ - [Installing MindInsight](#installing-mindinsight)
+ - [Installing MindArmour](#installing-mindarmour)
+ - [Installing MindSpore Hub](#installing-mindspore-hub)
+
+
+
+
+
+This document describes how to quickly install MindSpore in a Linux system with an Ascend 910 environment by pip.
+
+## System Environment Information Confirmation
+
+- Confirm that Ubuntu 18.04/CentOS 7.6/EulerOS 2.8 is installed with 64-bit operating system.
+- Confirm that [GCC 7.3.0](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz) is installed.
+- Confirm that [gmp 6.1.2](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz) is installed.
+- Confirm that Python 3.7.5 is installed.
+ - If you didn't install Python or you have installed other versions, please download the Python 3.7.5 64-bit from [Python](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz) or [Huaweicloud](https://mirrors.huaweicloud.com/python/3.7.5/Python-3.7.5.tgz) to install.
+- Confirm that the Ascend 910 AI processor software package (Atlas Data Center Solution V100R020C10：[A800-9000 1.0.8 (aarch64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9000-pid-250702818/software/252069004?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702818), [A800-9010 1.0.8 (x86_64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9010-pid-250702809/software/252062130?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702809), [CANN V100R020C10](https://support.huawei.com/enterprise/zh/ascend-computing/cann-pid-251168373/software/251174283?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C251168373)) are installed.
+- Confirm that the current user has the right to access the installation path `/usr/local/Ascend`of Ascend 910 AI processor software package, If not, the root user needs to add the current user to the user group where `/usr/local/Ascend` is located. For the specific configuration, please refer to the software package instruction document.
+ - Install the .whl package provided in Ascend 910 AI processor software package. The .whl package is released with the software package. After software package is upgraded, reinstall the .whl package.
+
+ ```bash
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/topi-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/te-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/hccl-{version}-py3-none-any.whl
+ ```
+
+## Installing MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/ascend/{system}/mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)). In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+- `{arch}` denotes the system architecture. For example, the Linux system you are using is x86 architecture 64-bit, `{arch}` should be `x86_64`. If the system is ARM architecture 64-bit, then it should be `aarch64`.
+- `{system}` denotes the system version. For example, if you are using EulerOS ARM architecture, `{system}` should be `euleros_aarch64`. Currently, the following systems are supported by Ascend: `euleros_aarch64`/`centos_aarch64`/`centos_x86`/`ubuntu_aarch64`/`ubuntu_x86`.
+
+## Configuring Environment Variables
+
+- **If Ascend 910 AI processor software is installed in a non-default path**, after MindSpore is installed, export runtime-related environment variables. `/usr/local/Ascend` in the following command `LOCAL_ASCEND=/usr/local/Ascend` denotes the installation path of the software package, please replace it as your actual installation path.
+
+ ```bash
+ # control log level. 0-DEBUG, 1-INFO, 2-WARNING, 3-ERROR, default level is WARNING.
+ export GLOG_v=2
+
+ # Conda environmental options
+ LOCAL_ASCEND=/usr/local/Ascend # the root directory of run package
+
+ # lib libraries that the run package depends on
+ export LD_LIBRARY_PATH=${LOCAL_ASCEND}/add-ons/:${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/lib64:${LOCAL_ASCEND}/driver/lib64:${LOCAL_ASCEND}/opp/op_impl/built-in/ai_core/tbe/op_tiling:${LD_LIBRARY_PATH}
+
+ # Environment variables that must be configured
+ export TBE_IMPL_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp/op_impl/built-in/ai_core/tbe # TBE operator implementation tool path
+ export ASCEND_OPP_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp # OPP path
+ export PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/ccec_compiler/bin/:${PATH} # TBE operator compilation tool path
+ export PYTHONPATH=${TBE_IMPL_PATH}:${PYTHONPATH}
+ # Python library that TBE implementation depends on
+ ```
+
+## Installation Verification
+
+- After configuring the environment variables, execute the following Python script：
+
+ ```python
+ import numpy as np
+ from mindspore import Tensor
+ import mindspore.ops as ops
+ import mindspore.context as context
+
+ context.set_context(device_target="Ascend")
+ x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+ y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+ print(ops.tensor_add(x, y))
+ ```
+
+- The outputs should be the same as:
+
+ ```text
+ [[[ 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.]]]
+ ```
+
+It means MindSpore has been installed successfully.
+
+## Version Update
+
+Using the following command if you need update MindSpore version:
+
+```bash
+pip install --upgrade mindspore-ascend
+```
+
+## Installing MindInsight
+
+If you need to analyze information such as model scalars, graphs, computation graphs and model traceback, you can install MindInsight.
+
+For more details, please refer to [MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README.md).
+
+## Installing MindArmour
+
+If you need to conduct AI model security research or enhance the security of the model in you applications, you can install MindArmour.
+
+For more details, please refer to [MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README.md).
+
+## Installing MindSpore Hub
+
+If you need to access and experience MindSpore pre-trained models quickly, you can install MindSpore Hub.
+
+For more details, please refer to [MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README.md).
diff --git a/install/mindspore_ascend_install_source.md b/install/mindspore_ascend_install_source.md
new file mode 100644
index 0000000000000000000000000000000000000000..90618f95bafefe8d16fc21694739639902d67932
--- /dev/null
+++ b/install/mindspore_ascend_install_source.md
@@ -0,0 +1,177 @@
+# 源码编译方式安装MindSpore Ascend版本
+
+
+
+- [源码编译方式安装MindSpore Ascend版本](#源码编译方式安装mindspore-ascend版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [从代码仓下载源码](#从代码仓下载源码)
+ - [编译MindSpore](#编译mindspore)
+ - [安装MindSpore](#安装mindspore)
+ - [配置环境变量](#配置环境变量)
+ - [验证是否成功安装](#验证是否成功安装)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindInsight](#安装mindinsight)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在Ascend 910环境的Linux系统上，使用源码编译方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04/CentOS 7.6/EulerOS 2.8是64位操作系统。
+- 确认安装[GCC 7.3.0版本](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz)。
+- 确认安装[gmp 6.1.2版本](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz)。
+- 确认安装[Python 3.7.5版本](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz)。
+- 确认安装[OpenSSL 1.1.1及以上版本](https://github.com/openssl/openssl.git)。
+ - 安装完成后设置环境变量`export OPENSSL_ROOT_DIR=“OpenSSL安装目录”`。
+- 确认安装[CMake 3.18.3及以上版本](https://cmake.org/download/)。
+ - 安装完成后将CMake所在路径添加到系统环境变量。
+- 确认安装[patch 2.5及以上版本](http://ftp.gnu.org/gnu/patch/)。
+ - 安装完成后将patch所在路径添加到系统环境变量中。
+- 确认安装[wheel 0.32.0及以上版本](https://pypi.org/project/wheel/)。
+- 确认安装Ascend 910 AI处理器软件配套包（Atlas Data Center Solution V100R020C10：[A800-9000 1.0.8 (aarch64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9000-pid-250702818/software/252069004?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702818)，[A800-9010 1.0.8 (x86_64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9010-pid-250702809/software/252062130?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702809)，[CANN V100R020C10](https://support.huawei.com/enterprise/zh/ascend-computing/cann-pid-251168373/software/251174283?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C251168373)）。
+ - 确认当前用户有权限访问Ascend 910 AI处理器配套软件包的安装路径`/usr/local/Ascend`，若无权限，需要root用户将当前用户添加到`/usr/local/Ascend`所在的用户组，具体配置请详见配套软件包的说明文档。
+ - 安装Ascend 910 AI处理器配套软件包提供的whl包，whl包随配套软件包发布，升级配套软件包之后需要重新安装。
+
+ ```bash
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/topi-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/te-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/hccl-{version}-py3-none-any.whl
+ ```
+
+- 确认安装git工具。
+
+ Ubuntu系统用户，如果未安装，使用如下命令下载安装：
+
+ ```bash
+ apt-get install git
+ ```
+
+ EulerOS和CentOS系统用户，如果未安装，使用如下命令下载安装：
+
+ ```bash
+ yum install git
+ ```
+
+## 从代码仓下载源码
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## 编译MindSpore
+
+在源码根目录下执行如下命令。
+
+```bash
+bash build.sh -e ascend
+```
+
+其中：
+`build.sh`中默认的编译线程数为8，如果编译机性能较差可能会出现编译错误，可在执行中增加-j{线程数}来减少线程数量。如`bash build.sh -e ascend -j4`。
+
+## 安装MindSpore
+
+```bash
+chmod +x build/package/mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl
+pip install build/package/mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+
+## 配置环境变量
+
+**如果Ascend 910 AI处理器配套软件包没有安装在默认路径**，安装好MindSpore之后，需要导出Runtime相关环境变量，下述命令中`LOCAL_ASCEND=/usr/local/Ascend`的`/usr/local/Ascend`表示配套软件包的安装路径，需注意将其改为配套软件包的实际安装路径。
+
+```bash
+# control log level. 0-DEBUG, 1-INFO, 2-WARNING, 3-ERROR, default level is WARNING.
+export GLOG_v=2
+
+# Conda environmental options
+LOCAL_ASCEND=/usr/local/Ascend # the root directory of run package
+
+# lib libraries that the run package depends on
+export LD_LIBRARY_PATH=${LOCAL_ASCEND}/add-ons/:${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/lib64:${LOCAL_ASCEND}/driver/lib64:${LOCAL_ASCEND}/opp/op_impl/built-in/ai_core/tbe/op_tiling:${LD_LIBRARY_PATH}
+
+# Environment variables that must be configured
+export TBE_IMPL_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp/op_impl/built-in/ai_core/tbe # TBE operator implementation tool path
+export ASCEND_OPP_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp # OPP path
+export PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/ccec_compiler/bin/:${PATH} # TBE operator compilation tool path
+export PYTHONPATH=${TBE_IMPL_PATH}:${PYTHONPATH} # Python library that TBE implementation depends on
+```
+
+## 验证是否成功安装
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="Ascend")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+如果输出：
+
+```text
+[[[ 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.]]]
+```
+
+说明MindSpore安装成功了。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+- 直接在线升级
+
+ ```bash
+ pip install --upgrade mindspore-ascend
+ ```
+
+- 本地源码编译升级
+
+ 在源码根目录下执行编译脚本`build.sh`成功后，在`build/package`目录下找到编译生成的whl安装包，然后执行命令进行升级。
+
+ ```bash
+ pip install --upgrade mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl
+ ```
+
+## 安装MindInsight
+
+当您需要查看训练过程中的标量、图像、计算图以及模型超参等信息时，可以选装MindInsight。
+
+具体安装步骤参见[MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README_CN.md)。
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_ascend_install_source_en.md b/install/mindspore_ascend_install_source_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..cedf7e0a21fe69a762d2f67d0e6d740ea469b389
--- /dev/null
+++ b/install/mindspore_ascend_install_source_en.md
@@ -0,0 +1,180 @@
+# Installing MindSpore in Ascend by Source Code
+
+
+
+- [Installing MindSpore in Ascend by Source Code](#installing-mindspore-in-ascend-by-source-code)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Downloading Source Code from Code Repository](#downloading-source-code-from-code-repository)
+ - [Compiling MindSpore](#compiling-mindspore)
+ - [Installing MindSpore](#installing-mindspore)
+ - [Configuring Environment Variables](#configuring-environment-variables)
+ - [Installation Verification](#installation-verification)
+ - [Version Update](#version-update)
+ - [Installing MindInsight](#installing-mindinsight)
+ - [Installing MindArmour](#installing-mindarmour)
+ - [Installing MindSpore Hub](#installing-mindspore-hub)
+
+
+
+
+
+This document describes how to quickly install MindSpore in a Linux system with an Ascend 910 environment by source code.
+
+## System Environment Information Confirmation
+
+- Confirm that Ubuntu 18.04/CentOS 7.6/EulerOS 2.8 is installed with 64-bit operating system.
+- Confirm that [GCC 7.3.0](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz) is installed.
+- Confirm that [gmp 6.1.2](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz) is installed.
+- Confirm that [Python 3.7.5](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz) is installed.
+- Confirm that [OpenSSL 1.1.1 or later](https://github.com/openssl/openssl.git) is installed.
+ - Set system variable `export OPENSSL_ROOT_DIR="OpenSSL installation directory"` after installation.
+- Confirm that [CMake 3.18.3 or later](https://cmake.org/download/) is installed.
+ - Add the path where the executable file `cmake` stores to the environment variable PATH.
+- Confirm that [patch 2.5 or later](http://ftp.gnu.org/gnu/patch/) is installed.
+ - Add the path where the executable file `patch` stores to the environment variable PATH.
+- Confirm that [wheel 0.32.0 or later](https://pypi.org/project/wheel/) is installed.
+- Confirm that the Ascend 910 AI processor software package (Atlas Data Center Solution V100R020C10：[A800-9000 1.0.8 (aarch64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9000-pid-250702818/software/252069004?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702818), [A800-9010 1.0.8 (x86_64)](https://support.huawei.com/enterprise/zh/ascend-computing/a800-9010-pid-250702809/software/252062130?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C250702809), [CANN V100R020C10](https://support.huawei.com/enterprise/zh/ascend-computing/cann-pid-251168373/software/251174283?idAbsPath=fixnode01%7C23710424%7C251366513%7C22892968%7C251168373)) are installed.
+- Confirm that the current user has the right to access the installation path `/usr/local/Ascend`of Ascend 910 AI processor software package, If not, the root user needs to add the current user to the user group where `/usr/local/Ascend` is located. For the specific configuration, please refer to the software package instruction document.
+ - Install the .whl package provided in Ascend 910 AI processor software package. The .whl package is released with the software package. After software package is upgraded, reinstall the .whl package.
+
+ ```bash
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/topi-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/te-{version}-py3-none-any.whl
+ pip install /usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/hccl-{version}-py3-none-any.whl
+ ```
+
+- Confirm that the git tool is installed.
+
+ If not, for Ubuntu users, use the following command to install it:
+
+ ```bash
+ apt-get install git
+ ```
+
+ If not, for EulerOS and CentOS users, use the following command to install it:
+
+ ```bash
+ yum install git
+ ```
+
+## Downloading Source Code from Code Repository
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## Compiling MindSpore
+
+Run the following command in the root directory of the source code to compile MindSpore:
+
+```bash
+bash build.sh -e ascend
+```
+
+Of which,
+
+- In the `build.sh` script, the default number of compilation threads is 8. If the compiler performance is poor, compilation errors may occur. You can add -j{Number of threads} in to script to reduce the number of threads. For example, `bash build.sh -e ascend -j4`.
+
+## Installing MindSpore
+
+```bash
+chmod +x build/package/mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl
+pip install build/package/mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)). In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+- `{arch}` denotes the system architecture. For example, the Linux system you are using is x86 architecture 64-bit, `{arch}` should be `x86_64`. If the system is ARM architecture 64-bit, then it should be `aarch64`.
+
+## Configuring Environment Variables
+
+- **If Ascend 910 AI processor software is installed in a non-default path**, after MindSpore is installed, export runtime-related environment variables. `/usr/local/Ascend` in the following command `LOCAL_ASCEND=/usr/local/Ascend` denotes the installation path of the software package, please replace it as your actual installation path.
+
+ ```bash
+ # control log level. 0-DEBUG, 1-INFO, 2-WARNING, 3-ERROR, default level is WARNING.
+ export GLOG_v=2
+
+ # Conda environmental options
+ LOCAL_ASCEND=/usr/local/Ascend # the root directory of run package
+
+ # lib libraries that the run package depends on
+ export LD_LIBRARY_PATH=${LOCAL_ASCEND}/add-ons/:${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/lib64:${LOCAL_ASCEND}/driver/lib64:${LOCAL_ASCEND}/opp/op_impl/built-in/ai_core/tbe/op_tiling:${LD_LIBRARY_PATH}
+
+ # Environment variables that must be configured
+ export TBE_IMPL_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp/op_impl/built-in/ai_core/tbe # TBE operator implementation tool path
+ export ASCEND_OPP_PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/opp # OPP path
+ export PATH=${LOCAL_ASCEND}/ascend-toolkit/latest/fwkacllib/ccec_compiler/bin/:${PATH} # TBE operator compilation tool path
+ export PYTHONPATH=${TBE_IMPL_PATH}:${PYTHONPATH}
+ # Python library that TBE implementation depends on
+
+ ```
+
+## Installation Verification
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="Ascend")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+- The outputs should be the same as:
+
+```text
+[[[ 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.]]]
+```
+
+It means MindSpore has been installed successfully.
+
+## Version Update
+
+Using the following command if you need update MindSpore version.
+
+- Update Online
+
+ ```bash
+ pip install --upgrade mindspore-ascend
+ ```
+
+- Update after source code compilation
+
+ After successfully executing the compile script `build.sh` in the root path of the source code, find the `whl` package in path `build/package`, use the following command to update your version.
+
+ ```bash
+ pip install --upgrade mindspore_ascend-{version}-cp37-cp37m-linux_{arch}.whl
+ ```
+
+## Installing MindInsight
+
+If you need to analyze information such as model scalars, graphs, computation graphs and model traceback, you can install MindInsight.
+
+For more details, please refer to [MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README.md).
+
+## Installing MindArmour
+
+If you need to conduct AI model security research or enhance the security of the model in you applications, you can install MindArmour.
+
+For more details, please refer to [MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README.md).
+
+## Installing MindSpore Hub
+
+If you need to access and experience MindSpore pre-trained models quickly, you can install MindSpore Hub.
+
+For more details, please refer to [MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README.md).
diff --git a/install/mindspore_cpu_install_conda.md b/install/mindspore_cpu_install_conda.md
new file mode 100644
index 0000000000000000000000000000000000000000..08aed993defc50354a5a391a49fc558d8933367d
--- /dev/null
+++ b/install/mindspore_cpu_install_conda.md
@@ -0,0 +1,91 @@
+# Conda方式安装MindSpore CPU版本
+
+
+
+- [Conda方式安装MindSpore CPU版本](#conda方式安装mindspore-cpu版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [安装Conda](#安装conda)
+ - [添加Conda镜像源](#添加conda镜像源)
+ - [创建并激活Conda环境](#创建并激活conda环境)
+ - [安装MindSpore](#安装mindspore)
+ - [验证安装是否成功](#验证安装是否成功)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在CPU环境的Linux系统上，使用Conda方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04是64位操作系统。
+- 确认安装[gmp 6.1.2版本](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz)。
+
+## 安装Conda
+
+下载并安装对应架构的Conda安装包。
+
+- 官网下载地址：[X86 Anaconda](https://www.anaconda.com/distribution/) 或 [X86 Miniconda](https://docs.conda.io/en/latest/miniconda.html)
+
+- 清华镜像源下载地址：[X86 Anaconda](https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.02-Linux-x86_64.sh)
+
+## 添加Conda镜像源
+
+从清华源镜像源下载Conda安装包的可跳过此步操作。
+
+```bash
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
+conda config --set show_channel_urls yes
+```
+
+## 创建并激活Conda环境
+
+```bash
+conda create -n mindspore python=3.7.5
+conda activate mindspore
+```
+
+## 安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/cpu/{system}/mindspore-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+- `{system}`表示系统，例如使用的Ubuntu系统X86架构，`{system}`应写为`ubuntu_x86`，目前CPU版本可支持以下系统`ubuntu_aarch64`/`ubuntu_x86`。
+
+## 验证安装是否成功
+
+```bash
+python -c "import mindspore;print(mindspore.__version__)"
+```
+
+如果输出MindSpore版本号，说明MindSpore安装成功了，如果输出`No module named 'mindspore'`说明未成功安装。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore
+```
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_cpu_install_pip.md b/install/mindspore_cpu_install_pip.md
new file mode 100644
index 0000000000000000000000000000000000000000..29a07c9cedbe654ec016a4581233e04ee68988c0
--- /dev/null
+++ b/install/mindspore_cpu_install_pip.md
@@ -0,0 +1,65 @@
+# pip方式安装MindSpore CPU版本
+
+
+
+- [pip方式安装MindSpore CPU版本](#pip方式安装mindspore-cpu版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [下载安装MindSpore](#下载安装mindspore)
+ - [查询安装是否成功](#查询安装是否成功)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在CPU环境的Linux系统上，使用pip方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04是64位操作系统。
+- 确认安装[GCC 7.3.0版本](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz)。
+- 确认安装Python 3.7.5版本。
+ - 如果未安装或者已安装其他版本的Python，可从[官网](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz)或者[华为云](https://mirrors.huaweicloud.com/python/3.7.5/Python-3.7.5.tgz)下载Python 3.7.5版本，进行安装。
+
+## 下载安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/cpu/{system}/mindspore-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+- `{system}`表示系统，例如使用的Ubuntu系统X86架构，`{system}`应写为`ubuntu_x86`，目前CPU版本可支持以下系统`ubuntu_aarch64`/`ubuntu_x86`。
+
+## 查询安装是否成功
+
+```bash
+python -c "import mindspore;print(mindspore.__version__)"
+```
+
+如果输出MindSpore版本号，说明MindSpore安装成功了，如果输出`No module named 'mindspore'`说明未成功安装。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore
+```
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_cpu_install_pip_en.md b/install/mindspore_cpu_install_pip_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..107271489adaf590d05229bac6118fce89b63d26
--- /dev/null
+++ b/install/mindspore_cpu_install_pip_en.md
@@ -0,0 +1,65 @@
+# Installing MindSpore in CPU by pip
+
+
+
+- [Installing MindSpore in CPU by pip](#installing-mindspore-in-cpu-by-pip)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Downloading and Installing MindSpore](#downloading-and-installing-mindspore)
+ - [Installation Verification](#installation-verification)
+ - [Version Update](#version-update)
+ - [Installing MindArmour](#installing-mindarmour)
+ - [Installing MindSpore Hub](#installing-mindspore-hub)
+
+
+
+
+
+This document describes how to quickly install MindSpore by pip in a Linux system with a CPU environment.
+
+## System Environment Information Confirmation
+
+- Confirm that Ubuntu 18.04 is installed with 64-bit operating system.
+- Confirm that [GCC 7.3.0](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz) is installed.
+- Confirm that Python 3.7.5 is installed.
+ - If you didn't install Python or you have installed other versions, please download the Python 3.7.5 64-bit from [Python](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz) or [Huaweicloud](https://mirrors.huaweicloud.com/python/3.7.5/Python-3.7.5.tgz) to install.
+
+## Downloading and Installing MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/cpu/{system}/mindspore-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)). In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+- `{arch}` denotes the system architecture. For example, the Linux system you are using is x86 architecture 64-bit, `{arch}` should be `x86_64`. If the system is ARM architecture 64-bit, then it should be `aarch64`.
+- `{system}` denotes the system version. For example, if you are using Ubuntu x86 architecture, `{system}` should be `ubuntu_x86`. Currently, the following systems are supported by CPU: `ubuntu_aarch64`/`ubuntu_x86`.
+
+## Installation Verification
+
+```bash
+python -c "import mindspore;print(mindspore.__version__)"
+```
+
+If the MindSpore version number is output, it means that MindSpore is installed successfully, and if the output is `No module named 'mindspore'`, it means that the installation was not successful.
+
+## Version Update
+
+Using the following command if you need update MindSpore version:
+
+```bash
+pip install --upgrade mindspore
+```
+
+## Installing MindArmour
+
+If you need to conduct AI model security research or enhance the security of the model in you applications, you can install MindArmour.
+
+For more details, please refer to [MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README.md).
+
+## Installing MindSpore Hub
+
+If you need to access and experience MindSpore pre-trained models quickly, you can install MindSpore Hub.
+
+For more details, please refer to [MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README.md).
diff --git a/install/mindspore_cpu_install_source.md b/install/mindspore_cpu_install_source.md
new file mode 100644
index 0000000000000000000000000000000000000000..979211ecf7fa30a8f7b24b2be89ef1630be04945
--- /dev/null
+++ b/install/mindspore_cpu_install_source.md
@@ -0,0 +1,106 @@
+# 源码编译方式安装MindSpore CPU版本
+
+
+
+- [源码编译方式安装MindSpore CPU版本](#源码编译方式安装mindspore-cpu版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [从代码仓下载源码](#从代码仓下载源码)
+ - [编译MindSpore](#编译mindspore)
+ - [安装MindSpore](#安装mindspore)
+ - [验证安装是否成功](#验证安装是否成功)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在CPU环境的Linux系统上，使用源码编译方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04是64位操作系统。
+- 确认安装[GCC 7.3.0版本](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz)。
+- 确认安装[Python 3.7.5版本](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz)。
+- 确认安装[OpenSSL 1.1.1及以上版本](https://github.com/openssl/openssl.git)。
+ - 安装完成后设置环境变量`export OPENSSL_ROOT_DIR=“OpenSSL安装目录”`。
+- 确认安装[CMake 3.18.3及以上版本](https://cmake.org/download/)。
+ - 安装完成后需将CMake所在路径添加到系统环境变量。
+- 确认安装[wheel 0.32.0及以上版本](https://pypi.org/project/wheel/)。
+- 确认安装[patch 2.5及以上版本](http://ftp.gnu.org/gnu/patch/)。
+ - 安装完成后需将patch所在路径添加到系统环境变量中。
+- 确认安装git工具。
+ 如果未安装，使用如下命令下载安装：
+
+ ```bash
+ apt-get install git
+ ```
+
+## 从代码仓下载源码
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## 编译MindSpore
+
+在源码根目录下执行如下命令。
+
+```bash
+bash build.sh -e cpu -j4
+```
+
+其中：
+如果编译机性能较好，可在执行中增加-j{线程数}来增加线程数量。如`bash build.sh -e cpu -j12`。
+
+## 安装MindSpore
+
+```bash
+chmod +x build/package/mindspore-{version}-cp37-cp37m-linux_{arch}.whl
+pip install build/package/mindspore-{version}-cp37-cp37m-linux_{arch}.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+
+## 验证安装是否成功
+
+```bash
+python -c 'import mindspore;print(mindspore.__version__)'
+```
+
+如果输出MindSpore版本号，说明MindSpore安装成功了，如果输出`No module named 'mindspore'`说明未安装成功。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+- 直接在线升级
+
+ ```bash
+ pip install --upgrade mindspore
+ ```
+
+- 本地源码编译升级
+
+ 在源码根目录下执行编译脚本`build.sh`成功后，在`build/package`目录下找到编译生成的whl安装包，然后执行命令进行升级。
+
+ ```bash
+ pip install --upgrade mindspore-{version}-cp37-cp37m-linux_{arch}.whl
+ ```
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_cpu_install_source_en.md b/install/mindspore_cpu_install_source_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..f61a19aecb51a8a9d43962a930c591fcd5d7527f
--- /dev/null
+++ b/install/mindspore_cpu_install_source_en.md
@@ -0,0 +1,107 @@
+# Installing MindSpore in CPU by Source Code
+
+
+
+- [Installing MindSpore in CPU by Source Code](#installing-mindspore-in-cpu-by-source-code)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Downloading Source Code from Code Repository](#downloading-source-code-from-code-repository)
+ - [Compiling MindSpore](#compiling-mindspore)
+ - [Installing MindSpore](#installing-mindspore)
+ - [Installation Verification](#installation-verification)
+ - [Version Update](#version-update)
+ - [Installing MindArmour](#installing-mindarmour)
+ - [Installing MindSpore Hub](#installing-mindspore-hub)
+
+
+
+
+
+This document describes how to quickly install MindSpore by source code in a Linux system with a CPU environment.
+
+## System Environment Information Confirmation
+
+- Confirm that Ubuntu 18.04 is installed with 64-bit operating system.
+- Confirm that [GCC 7.3.0](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz) is installed.
+- Confirm that [Python 3.7.5](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz) is installed.
+- Confirm that [OpenSSL 1.1.1 or later](https://github.com/openssl/openssl.git) is installed.
+ - Set system variable `export OPENSSL_ROOT_DIR="OpenSSL installation directory"` after installation.
+- Confirm that [CMake 3.18.3 or later](https://cmake.org/download/) is installed.
+ - Add the path where the executable file `cmake` stores to the environment variable PATH.
+- Confirm that [wheel 0.32.0 or later](https://pypi.org/project/wheel/) is installed.
+- Confirm that [patch 2.5 or later](http://ftp.gnu.org/gnu/patch/) is installed.
+ - Add the path where the executable file `patch` stores to the environment variable PATH.
+- Confirm that the git tool is installed.
+ If not, use the following command to install it:
+
+ ```bash
+ apt-get install git
+ ```
+
+## Downloading Source Code from Code Repository
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## Compiling MindSpore
+
+Run the following command in the root directory of the source code to compile MindSpore:
+
+```bash
+bash build.sh -e cpu -j4
+```
+
+Of which,
+
+- If the compiler performance is strong, you can add -j{Number of threads} in to script to increase the number of threads. For example, `bash build.sh -e cpu -j12`.
+
+## Installing MindSpore
+
+```bash
+chmod +x build/package/mindspore-{version}-cp37-cp37m-linux_{arch}.whl
+pip install build/package/mindspore-{version}-cp37-cp37m-linux_{arch}.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt))，In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+- `{arch}` denotes the system architecture. For example, the Linux system you are using is x86 architecture 64-bit, `{arch}` should be `x86_64`. If the system is ARM architecture 64-bit, then it should be `aarch64`.
+
+## Installation Verification
+
+```bash
+python -c 'import mindspore;print(mindspore.__version__)'
+```
+
+If the MindSpore version number is output, it means that MindSpore is installed successfully, and if the output is `No module named'mindspore'`, it means that the installation was not successful.
+
+## Version Update
+
+Using the following command if you need update MindSpore version:
+
+- Update online
+
+ ```bash
+ pip install --upgrade mindspore
+ ```
+
+- Update after source code compilation
+
+ After successfully executing the compile script `build.sh` in the root path of the source code, find the `whl` package in path `build/package`, use the following command to update your version.
+
+ ```bash
+ pip install --upgrade mindspore-{version}-cp37-cp37m-linux_{arch}.whl
+ ```
+
+## Installing MindArmour
+
+If you need to conduct AI model security research or enhance the security of the model in you applications, you can install MindArmour.
+
+For more details, please refer to [MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README.md).
+
+## Installing MindSpore Hub
+
+If you need to access and experience MindSpore pre-trained models quickly, you can install MindSpore Hub.
+
+For more details, please refer to [MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README.md).
diff --git a/install/mindspore_cpu_win_install_conda.md b/install/mindspore_cpu_win_install_conda.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b62bcd653fd1f14888d783978c3884d45756e2d
--- /dev/null
+++ b/install/mindspore_cpu_win_install_conda.md
@@ -0,0 +1,78 @@
+# Conda方式安装MindSpore CPU版本（Windows）
+
+
+
+- [Conda方式安装MindSpore CPU版本（Windows）](#conda方式安装mindspore-cpu版本windows)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [安装Conda](#安装conda)
+ - [启动Anaconda Prompt](#启动anaconda-prompt)
+ - [添加Conda镜像源](#添加conda镜像源)
+ - [创建并激活Conda环境](#创建并激活conda环境)
+ - [安装MindSpore](#安装mindspore)
+ - [验证是否安装成功](#验证是否安装成功)
+ - [升级MindSpore版本](#升级mindspore版本)
+
+
+
+
+
+本文档介绍如何在CPU环境的Windows系统上，使用Conda方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Windows 10是x86架构64位操作系统。
+
+## 安装Conda
+
+下载并安装对应架构的Conda安装包。
+
+- 官方源下载[X86 Anaconda](https://www.anaconda.com/distribution/) 或 [X86 Miniconda](https://docs.conda.io/en/latest/miniconda.html)
+- 清华镜像源下载地址：[X86 Anaconda](https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.02-Windows-x86_64.exe)
+
+## 启动Anaconda Prompt
+
+安装Conda后，从Windows“开始”菜单打开“Anaconda Prompt”。
+
+## 添加Conda镜像源
+
+从清华源镜像源下载Conda安装包的可忽略此步操作。
+
+```shell
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
+conda config --set show_channel_urls yes
+```
+
+## 创建并激活Conda环境
+
+```bash
+conda create -n mindspore python=3.7.5
+conda activate mindspore
+```
+
+## 安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/cpu/windows_x64/mindspore-{version}-cp37-cp37m-win_amd64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+
+## 验证是否安装成功
+
+```bash
+python -c "import mindspore;mindspore.__version__"
+```
+
+如果输出MindSpore版本号，说明MindSpore安装成功了，如果输出`No module named 'mindspore'`说明未安装成功。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore
+```
diff --git a/install/mindspore_cpu_win_install_pip.md b/install/mindspore_cpu_win_install_pip.md
new file mode 100644
index 0000000000000000000000000000000000000000..9a98d14fcf1e878be62b98b5e0efce6c0241e660
--- /dev/null
+++ b/install/mindspore_cpu_win_install_pip.md
@@ -0,0 +1,51 @@
+# pip方式安装MindSpore CPU版本（Windows）
+
+
+
+- [pip方式安装MindSpore CPU版本（Windows）](#pip方式安装mindspore-cpu版本windows)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [安装MindSpore](#安装mindspore)
+ - [验证是否安装成功](#验证是否安装成功)
+ - [升级MindSpore版本](#升级mindspore版本)
+
+
+
+
+
+本文档介绍如何在CPU环境的Windows系统上，使用pip方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Windows 10是x86架构64位操作系统。
+- 确认安装Python 3.7.5版本。
+ - 如果未安装或者已安装其他版本的Python，则需从华为云下载[Python 3.7.5版本 64位](https://mirrors.huaweicloud.com/python/3.7.5/python-3.7.5-amd64.exe)进行安装。
+- 安装Python完毕后，将Python和pip添加到系统环境变量。
+ - 添加Python：控制面板->系统->高级系统设置->环境变量。双击系统变量中的Path，将`python.exe`的路径添加进去。
+ - 添加pip：`python.exe`同一级目录中的`Scripts`文件夹即为Python自带的pip文件，将其路径添加到系统环境变量中即可。
+
+## 安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/cpu/windows_x64/mindspore-{version}-cp37-cp37m-win_amd64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+
+## 验证是否安装成功
+
+```bash
+python -c "import mindspore;print(mindspore.__version__)"
+```
+
+如果输出MindSpore版本号，说明MindSpore安装成功了，如果输出`No module named 'mindspore'`说明未安装成功。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore
+```
diff --git a/install/mindspore_cpu_win_install_pip_en.md b/install/mindspore_cpu_win_install_pip_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..a90fc46d5507efd445aa69e73dbe8020e3457638
--- /dev/null
+++ b/install/mindspore_cpu_win_install_pip_en.md
@@ -0,0 +1,51 @@
+# Installing MindSpore in CPU by pip (Windows)
+
+
+
+- [Installing MindSpore in CPU by pip (Windows)](#installing-mindspore-in-cpu-by-pip-windows)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Installing MindSpore](#installing-mindspore)
+ - [Installation Verification](#installation-verification)
+ - [Version Update](#version-update)
+
+
+
+
+
+This document describes how to quickly install MindSpore by pip in a Windows system with a CPU environment.
+
+## System Environment Information Confirmation
+
+- Confirm that Windows 10 is installed with x86 architecture 64-bit operating system.
+- Confirm that Python 3.7.5 is installed.
+ - If you didn't install Python or you have installed other versions, please download the Python 3.7.5 64-bit from [Huaweicloud](https://mirrors.huaweicloud.com/python/3.7.5/Python-3.7.5.tgz) to install.
+- After installing Python, add Python and pip to the environment variable.
+ - Add Python: Control Panel -> System -> Advanced System Settings -> Environment Variables. Double click the Path in the environment variable and add the path of `python.exe`.
+ - Add pip: The `Scripts` folder in the same directory of `python.exe` is the pip file that comes with Python, add it to the system environment variable.
+
+## Installing MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/cpu/windows_x64/mindspore-{version}-cp37-cp37m-win_amd64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)). In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+
+## Installation Verification
+
+```bash
+python -c "import mindspore;print(mindspore.__version__)"
+```
+
+If the MindSpore version number is output, it means that MindSpore is installed successfully, and if the output is `No module named 'mindspore'`, it means that the installation was not successful.
+
+## Version Update
+
+Using the following command if you need update MindSpore version:
+
+```bash
+pip install --upgrade mindspore
+```
diff --git a/install/mindspore_cpu_win_install_source.md b/install/mindspore_cpu_win_install_source.md
new file mode 100644
index 0000000000000000000000000000000000000000..5e5ea49b13c00faeec9364ec2d8a2c1a8f1d4232
--- /dev/null
+++ b/install/mindspore_cpu_win_install_source.md
@@ -0,0 +1,83 @@
+# 源码编译方式安装MindSpore CPU版本（Windows）
+
+
+
+- [源码编译方式安装MindSpore CPU版本（Windows）](#源码编译方式安装mindspore-cpu版本windows)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [从代码仓下载源码](#从代码仓下载源码)
+ - [编译MindSpore](#编译mindspore)
+ - [安装MindSpore](#安装mindspore)
+ - [验证是否安装成功](#验证是否安装成功)
+ - [升级MindSpore版本](#升级mindspore版本)
+
+
+
+
+
+本文档介绍如何在CPU环境的Windows系统上，使用源码编译方法快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Windows 10是x86架构64位操作系统。
+- 确认安装[Visual C++ Redistributable for Visual Studio 2015](https://www.microsoft.com/zh-CN/download/details.aspx?id=48145)。
+- 确认安装了[git](https://github.com/git-for-windows/git/releases/download/v2.29.2.windows.2/Git-2.29.2.2-64-bit.exe)工具。
+ - 如果git没有安装在`ProgramFiles`，在执行上述命令前，需设置环境变量指定`patch.exe`的位置，例如git安装在`D:\git`时，需设置`set MS_PATCH_PATH=D:\git\usr\bin`。
+- 确认安装[MinGW-W64 GCC-7.3.0](https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/7.3.0/threads-posix/seh/x86_64-7.3.0-release-posix-seh-rt_v5-rev0.7z)。
+ - 安装路径中不能出现中文和日文，安装完成后将安装路径下的`MinGW\bin`添加到系统环境变量。例如安装在`D:\gcc`，则需要将`D:\gcc\MinGW\bin`添加到系统环境变量Path中。
+- 确认安装[CMake 3.18.3版本](https://cmake.org/download/)。
+ - 安装路径中不能出现中文和日文，安装完成后将`cmake.exe`的路径添加到系统环境变量Path中。
+- 确认安装[ActivePerl 5.28.1.2801版本](https://downloads.activestate.com/ActivePerl/releases/5.28.1.2801/ActivePerl-5.28.1.2801-MSWin32-x64-24563874.exe)。
+- 确认安装[Python 3.7.5版本](https://www.python.org/ftp/python/3.7.5/python-3.7.5-amd64.exe)。
+ - 安装路径中不能出现中文和日文，安装完成后需要将`python.exe`的路径添加到系统环境变量Path中，Python自带的pip文件在`python.exe`同级目录的`Scripts`文件夹中，也需要将pip文件的路径添加到系统环境变量Path中。
+- 确认安装[wheel 0.32.0及以上版本](https://pypi.org/project/wheel/)。
+
+## 从代码仓下载源码
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## 编译MindSpore
+
+在源码根目录下执行如下命令：
+
+```bash
+call build.bat
+```
+
+## 安装MindSpore
+
+```bash
+pip install build/package/mindspore-{version}-cp37-cp37m-win_amd64.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+
+## 验证是否安装成功
+
+```bash
+python -c "import mindspore;print(mindspore.__version__)"
+```
+
+如果输出MindSpore版本号，说明MindSpore安装成功了，如果输出`No module named 'mindspore'`说明未安装成功。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+- 直接在线升级
+
+ ```bash
+ pip install --upgrade mindspore
+ ```
+
+- 本地源码编译升级
+
+ 在源码根目录下执行编译脚本`build.sh`成功后，在`build/package`目录下找到编译生成的whl安装包，然后执行命令进行升级。
+
+ ```bash
+ pip install --upgrade mindspore-{version}-cp37-cp37m-win_amd64.whl
+ ```
diff --git a/install/mindspore_cpu_win_install_source_en.md b/install/mindspore_cpu_win_install_source_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8ecf510d79536ca52ad8fb8153af2914d9a786c
--- /dev/null
+++ b/install/mindspore_cpu_win_install_source_en.md
@@ -0,0 +1,83 @@
+# Installing MindSpore in CPU by Source Code (Windows)
+
+
+
+- [Installing MindSpore in CPU by Source Code (Windows)](#installing-mindspore-in-cpu-by-source-code-windows)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Downloading Source Code from Code Repository](#downloading-source-code-from-code-repository)
+ - [Compiling MindSpore](#compiling-mindspore)
+ - [Installing MindSpore](#installing-mindspore)
+ - [Installation Verification](#installing-verification)
+ - [Version Update](#version-update)
+
+
+
+
+
+This document describes how to quickly install MindSpore by source code in a Windows system with a CPU environment.
+
+## System Environment Information Confirmation
+
+- Confirm that Windows 10 is installed with x86 architecture 64-bit operating system.
+- Confirm that [Visual C++ Redistributable for Visual Studio 2015](https://www.microsoft.com/zh-CN/download/details.aspx?id=48145) is installed.
+- Confirm that [git](https://github.com/git-for-windows/git/releases/download/v2.29.2.windows.2/Git-2.29.2.2-64-bit.exe) tool is installed.
+ - If git was not installed in `ProgramFiles`, you will need to set environment variable to where `patch.exe` is allocated. For example, when git was install in `D:\git`, `set MS_PATCH_PATH=D:\git\usr\bin`.
+- Confirm that [MinGW-W64 GCC-7.3.0](https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win64/Personal%20Builds/mingw-builds/7.3.0/threads-posix/seh/x86_64-7.3.0-release-posix-seh-rt_v5-rev0.7z) is installed.
+ - Ensure that path of source code does not include special characters (Chinese, Janpanese characters etc.). After installing, add the path `MinGW\bin`to the environment variable PATH.For example, the installation directory is in `D:\gcc`, then you will need to add `D:\gcc\MinGW\bin` to the system environment variable PATH.
+- Confirm that [CMake 3.18.3](https://cmake.org/download/) is installed.
+ - Ensure that path of source code does not include special characters (Chinese, Janpanese characters etc.). After installing, add the path of `cmake.exe` to the environment variable PATH.
+- Confirm that [ActivePerl 5.28.1.2801](https://downloads.activestate.com/ActivePerl/releases/5.28.1.2801/ActivePerl-5.28.1.2801-MSWin32-x64-24563874.exe) is installed.
+- Confirm that [Python 3.7.5](https://www.python.org/ftp/python/3.7.5/python-3.7.5-amd64.exe) is installed.
+ - Ensure that path of source code does not include special characters (Chinese, Janpanese characters etc.). After installing, add the path of `python.exe` to the environment variable PATH. The `Scripts` folder in the same directory of `python.exe` is the pip file that comes with Python, you also need to add the path of the pip file to the environment variable PATH.
+- Confirm that [wheel 0.32.0 or later](https://pypi.org/project/wheel/) is installed.
+
+## Downloading Source Code from Code Repository
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## Compiling MindSpore
+
+Run the following command in the root directory of the source code to compile MindSpore:
+
+```bash
+call build.bat
+```
+
+## Installing MindSpore
+
+```bash
+pip install build/package/mindspore-{version}-cp37-cp37m-win_amd64.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)). In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+
+## Installation Verification
+
+```bash
+python -c "import mindspore;print(mindspore.__version__)"
+```
+
+If the MindSpore version number is output, it means that MindSpore is installed successfully, and if the output is `No module named 'mindspore'`, it means that the installation was not successful.
+
+## Version Update
+
+Using the following command if you need update MindSpore version:
+
+- Update online
+
+ ```bash
+ pip install --upgrade mindspore
+ ```
+
+- Update after source code compilation
+
+ After successfully executing the compile script `build.bat` in the root path of the source code, find the `whl` package in path `build/package`, use the following command to update your version.
+
+```bash
+pip install --upgrade mindspore-{version}-cp37-cp37m-win_amd64.whl
+```
diff --git a/install/mindspore_gpu_install_conda.md b/install/mindspore_gpu_install_conda.md
new file mode 100644
index 0000000000000000000000000000000000000000..2ca9b91a2d27dcbb46e2395a7798a6d501480e07
--- /dev/null
+++ b/install/mindspore_gpu_install_conda.md
@@ -0,0 +1,126 @@
+# Conda方式安装MindSpore GPU版本
+
+
+
+- [Conda方式安装MindSpore GPU版本](#conda方式安装mindspore-gpu版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [安装Conda](#安装conda)
+ - [添加Conda镜像源](#添加conda镜像源)
+ - [创建并激活Conda环境](#创建并激活conda环境)
+ - [安装MindSpore](#安装mindspore)
+ - [验证是否成功安装](#验证是否成功安装)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindInsight](#安装mindinsight)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在GPU环境的Linux系统上，使用Conda方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04是64位操作系统。
+- 确认安装[GCC 7.3.0版本](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz)。
+- 确认安装[CUDA 10.1](https://developer.nvidia.com/cuda-10.1-download-archive-base)。
+ - CUDA安装后，若CUDA没有安装在默认位置，需要设置环境变量PATH（如：`export PATH=/usr/local/cuda-${version}/bin:$PATH`）和`LD_LIBRARY_PATH`（如：`export LD_LIBRARY_PATH=/usr/local/cuda-${version}/lib64:$LD_LIBRARY_PATH`），详细安装后的设置可参考[CUDA安装手册](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#post-installation-actions)。
+- 确认安装[cuDNN 7.6.X版本](https://developer.nvidia.com/rdp/cudnn-archive)。
+- 确认安装[OpenMPI 3.1.5版本](https://www.open-mpi.org/faq/?category=building#easy-build)（可选，单机多卡/多机多卡训练需要）。
+- 确认安装[NCCL 2.7.6-1版本](https://docs.nvidia.com/deeplearning/sdk/nccl-install-guide/index.html#debian)（可选，单机多卡/多机多卡训练需要）。
+- 确认安装[gmp 6.1.2版本](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz)。
+
+## 安装Conda
+
+下载并安装对应架构的Conda安装包。
+
+- 官网下载地址：[X86 Anaconda](https://www.anaconda.com/distribution/) 或 [X86 Miniconda](https://docs.conda.io/en/latest/miniconda.html)。
+- 清华镜像源下载地址：[X86 Anaconda](https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/Anaconda3-2020.02-Linux-x86_64.sh)。
+
+## 添加Conda镜像源
+
+从清华源镜像源下载Conda安装包的可跳过此步操作。
+
+```bash
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
+conda config --set show_channel_urls yes
+```
+
+## 创建并激活Conda环境
+
+```bash
+conda create -n mindspore python=3.7.5
+conda activate mindspore
+```
+
+## 安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/gpu/ubuntu_x86/cuda-10.1/mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+
+## 验证是否成功安装
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="GPU")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+如果输出：
+
+```text
+[[[ 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.]]]
+```
+
+说明MindSpore安装成功了。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore-gpu
+```
+
+## 安装MindInsight
+
+当您需要查看训练过程中的标量、图像、计算图以及模型超参等信息时，可以选装MindInsight。
+
+具体安装步骤参见[MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README_CN.md)。
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_gpu_install_pip.md b/install/mindspore_gpu_install_pip.md
new file mode 100644
index 0000000000000000000000000000000000000000..43f34a4d7efc457eaadf9c7feea32d7de4e9b2c3
--- /dev/null
+++ b/install/mindspore_gpu_install_pip.md
@@ -0,0 +1,101 @@
+# pip方式安装MindSpore GPU版本
+
+
+
+- [pip方式安装MindSpore GPU版本](#pip方式安装mindspore-gpu版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [安装MindSpore](#安装mindspore)
+ - [验证是否成功安装](#验证是否成功安装)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindInsight](#安装mindinsight)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在GPU环境的Linux系统上，使用pip方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04是64位操作系统。
+- 确认安装[GCC 7.3.0版本](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz)。
+- 确认安装[CUDA 10.1](https://developer.nvidia.com/cuda-10.1-download-archive-base)。
+ - CUDA安装后，若CUDA没有安装在默认位置，需要设置环境变量PATH（如：`export PATH=/usr/local/cuda-${version}/bin:$PATH`）和`LD_LIBRARY_PATH`（如：`export LD_LIBRARY_PATH=/usr/local/cuda-${version}/lib64:$LD_LIBRARY_PATH`），详细安装后的设置可参考[CUDA安装手册](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#post-installation-actions)。
+- 确认安装[cuDNN 7.6.X版本](https://developer.nvidia.com/rdp/cudnn-archive)。
+- 确认安装[OpenMPI 3.1.5版本](https://www.open-mpi.org/faq/?category=building#easy-build)（可选，单机多卡/多机多卡训练需要）。
+- 确认安装[NCCL 2.7.6-1版本](https://docs.nvidia.com/deeplearning/sdk/nccl-install-guide/index.html#debian)（可选，单机多卡/多机多卡训练需要）。
+- 确认安装[gmp 6.1.2版本](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz)。
+- 确认安装Python 3.7.5版本。
+ - 如果未安装或者已安装其他版本的Python，可从[官网](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz)或者[华为云](https://mirrors.huaweicloud.com/python/3.7.5/Python-3.7.5.tgz)下载Python 3.7.5版本64位，进行安装。
+
+## 安装MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/gpu/ubuntu_x86/cuda-10.1/mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+
+## 验证是否成功安装
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="GPU")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+如果输出：
+
+```text
+[[[ 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.]]]
+```
+
+说明MindSpore安装成功了。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+```bash
+pip install --upgrade mindspore-gpu
+```
+
+## 安装MindInsight
+
+当您需要查看训练过程中的标量、图像、计算图以及模型超参等信息时，可以选装MindInsight。
+
+具体安装步骤参见[MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README_CN.md)。
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_gpu_install_pip_en.md b/install/mindspore_gpu_install_pip_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..f00c5a74b53090c098e354c11138fc43d6c80a54
--- /dev/null
+++ b/install/mindspore_gpu_install_pip_en.md
@@ -0,0 +1,101 @@
+# Installing MindSpore in GPU by pip
+
+
+
+- [Installing MindSpore in GPU by pip](#installing-mindspore-in-gpu-by-pip)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Installing MindSpore](#installing-mindspore)
+ - [Installation Verification](#installation-verification)
+ - [Version Update](#version-update)
+ - [Installing MindInsight](#installing-mindinsight)
+ - [Installing MindArmour](#installing-mindarmour)
+ - [Installing MindSpore Hub](#installing-mindspore-hub)
+
+
+
+
+
+This document describes how to quickly install MindSpore by pip in a Linux system with a GPU environment.
+
+## System Environment Information Confirmation
+
+- Confirm that Ubuntu 18.04 is installed with 64-bit operating system.
+- Confirm that [GCC 7.3.0](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz) is installed.
+- Confirm that [CUDA 10.1](https://developer.nvidia.com/cuda-10.1-download-archive-base) is installed.
+ - If CUDA is installed in a non-default path, after installing CUDA, environment variable `PATH`(e.g. `export PATH=/usr/local/cuda-${version}/bin:$PATH`) and `LD_LIBRARY_PATH`(e.g. `export LD_LIBRARY_PATH=/usr/local/cuda-${version}/lib64:$LD_LIBRARY_PATH`) need to be set. Please refer to [CUDA installation guide](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#post-installation-actions) for detailed post installation actions.
+- Confirm that [cuDNN 7.6.X](https://developer.nvidia.com/rdp/cudnn-archive) is installed.
+- Confirm that [OpenMPI 3.1.5](https://www.open-mpi.org/faq/?category=building#easy-build) is installed. (optional, required for single-node/multi-GPU and multi-node/multi-GPU training)
+- Confirm that [NCCL 2.7.6-1](https://docs.nvidia.com/deeplearning/sdk/nccl-install-guide/index.html#debian) is installed. (optional, required for single-node/multi-GPU and multi-node/multi-GPU training)
+- Confirm that [gmp 6.1.2](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz) is installed.
+- Confirm that Python 3.7.5 is installed.
+ - If you didn't install Python or you have installed other versions, please download the Python 3.7.5 64-bit from [Python](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz) or [Huaweicloud](https://mirrors.huaweicloud.com/python/3.7.5/Python-3.7.5.tgz) to install.
+
+## Installing MindSpore
+
+```bash
+pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindSpore/gpu/ubuntu_x86/cuda-10.1/mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)). In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+- `{arch}` denotes the system architecture. For example, the Linux system you are using is x86 architecture 64-bit, `{arch}` should be `x86_64`. If the system is ARM architecture 64-bit, then it should be `aarch64`.
+
+## Installation Verification
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="GPU")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+- The outputs should be the same as:
+
+```text
+[[[ 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.]]]
+```
+
+It means MindSpore has been installed successfully.
+
+## Version Update
+
+Using the following command if you need update MindSpore version:
+
+```bash
+pip install --upgrade mindspore-gpu
+```
+
+## Installing MindInsight
+
+If you need to analyze information such as model scalars, graphs, computation graphs and model traceback, you can install MindInsight.
+
+For more details, please refer to [MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README.md).
+
+## Installing MindArmour
+
+If you need to conduct AI model security research or enhance the security of the model in you applications, you can install MindArmour.
+
+For more details, please refer to [MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README.md).
+
+## Installing MindSpore Hub
+
+If you need to access and experience MindSpore pre-trained models quickly, you can install MindSpore Hub.
+
+For more details, please refer to [MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README.md).
diff --git a/install/mindspore_gpu_install_source.md b/install/mindspore_gpu_install_source.md
new file mode 100644
index 0000000000000000000000000000000000000000..9b402665664ea79fc9eb01f4c1f550b492f5cecd
--- /dev/null
+++ b/install/mindspore_gpu_install_source.md
@@ -0,0 +1,147 @@
+# 源码编译方式安装MindSpore GPU版本
+
+
+
+- [源码编译方式安装MindSpore GPU版本](#源码编译方式安装mindspore-gpu版本)
+ - [确认系统环境信息](#确认系统环境信息)
+ - [从代码仓下载源码](#从代码仓下载源码)
+ - [编译MindSpore](#编译mindspore)
+ - [安装MindSpore](#安装mindspore)
+ - [验证是否成功安装](#验证是否成功安装)
+ - [升级MindSpore版本](#升级mindspore版本)
+ - [安装MindInsight](#安装mindinsight)
+ - [安装MindArmour](#安装mindarmour)
+ - [安装MindSpore Hub](#安装mindspore-hub)
+
+
+
+
+
+本文档介绍如何在GPU环境的Linux系统上，使用源码编译方式快速安装MindSpore。
+
+## 确认系统环境信息
+
+- 确认安装Ubuntu 18.04是64位操作系统。
+- 确认安装[GCC 7.3.0版本](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz)。
+- 确认安装[gmp 6.1.2版本](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz)。
+- 确认安装[Python 3.7.5版本](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz)。
+- 确认安装[CMake 3.18.3及以上版本](https://cmake.org/download/)。
+ - 安装完成后将CMake添加到系统环境变量。
+- 确认安装[patch 2.5及以上版本](http://ftp.gnu.org/gnu/patch/)。
+ - 安装完成后将patch添加到系统环境变量中。
+- 确认安装[Autoconf 2.69及以上版本](https://www.gnu.org/software/autoconf)（可使用系统自带版本）。
+- 确认安装[Libtool 2.4.6-29.fc30及以上版本](https://www.gnu.org/software/libtool)（可使用系统自带版本）。
+- 确认安装[Automake 1.15.1及以上版本](https://www.gnu.org/software/automake)（可使用系统自带版本）。
+- 确认安装[cuDNN 7.6及以上版本](https://developer.nvidia.com/rdp/cudnn-archive)。
+- 确认安装[Flex 2.5.35及以上版本](https://github.com/westes/flex/)。
+- 确认安装[wheel 0.32.0及以上版本](https://pypi.org/project/wheel/)。
+- 确认安装[OpenSSL 1.1.1及以上版本](https://github.com/openssl/openssl.git)。
+ - 安装完成后设置环境变量`export OPENSSL_ROOT_DIR=“OpenSSL安装目录”`。
+- 确认安装[CUDA 10.1](https://developer.nvidia.com/cuda-10.1-download-archive-base)按默认配置安装。
+ - CUDA安装后，若CUDA没有安装在默认位置，需要设置环境变量PATH（如：`export PATH=/usr/local/cuda-${version}/bin:$PATH`）和`LD_LIBRARY_PATH`（如：`export LD_LIBRARY_PATH=/usr/local/cuda-${version}/lib64:$LD_LIBRARY_PATH`），详细安装后的设置可参考[CUDA安装手册](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#post-installation-actions)。
+- 确认安装[OpenMPI 3.1.5版本](https://www.open-mpi.org/faq/?category=building#easy-build)（可选，单机多卡/多机多卡训练需要）。
+- 确认安装[NCCL 2.7.6-1版本](https://docs.nvidia.com/deeplearning/sdk/nccl-install-guide/index.html#debian)（可选，单机多卡/多机多卡训练需要）。
+- 确认安装git工具。
+ 如果未安装，使用如下命令下载安装：
+
+ ```bash
+ apt-get install git
+ ```
+
+## 从代码仓下载源码
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## 编译MindSpore
+
+在源码根目录下执行如下命令。
+
+```bash
+bash build.sh -e gpu
+```
+
+其中：
+`build.sh`中默认的编译线程数为8，如果编译机性能较差可能会出现编译错误，可在执行中增加-j{线程数}来减少线程数量。如`bash build.sh -e gpu -j4`。
+
+## 安装MindSpore
+
+```bash
+chmod +x build/package/mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl
+pip install build/package/mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+其中：
+
+- 在联网状态下，安装whl包时会自动下载MindSpore安装包的依赖项（依赖项详情参见[requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)），其余情况需自行安装。
+- `{version}`表示MindSpore版本号，例如下载1.0.1版本MindSpore时，`{version}`应写为1.0.1。
+- `{arch}`表示系统架构，例如使用的Linux系统是x86架构64位时，`{arch}`应写为`x86_64`。如果系统是ARM架构64位，则写为`aarch64`。
+
+## 验证是否成功安装
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="GPU")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+如果输出：
+
+```text
+[[[ 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.]]]
+```
+
+说明MindSpore安装成功了。
+
+## 升级MindSpore版本
+
+当需要升级MindSpore版本时，可执行如下命令：
+
+- 直接在线升级
+
+ ```bash
+ pip install --upgrade mindspore-gpu
+ ```
+
+- 本地源码编译升级
+
+ 在源码根目录下执行编译脚本`build.sh`成功后，在`build/package`目录下找到编译生成的whl安装包，然后执行命令进行升级。
+
+ ```bash
+ pip install --upgrade mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl
+ ```
+
+## 安装MindInsight
+
+当您需要查看训练过程中的标量、图像、计算图以及模型超参等信息时，可以选装MindInsight。
+
+具体安装步骤参见[MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README_CN.md)。
+
+## 安装MindArmour
+
+当您进行AI模型安全研究或想要增强AI应用模型的防护能力时，可以选装MindArmour。
+
+具体安装步骤参见[MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README_CN.md)。
+
+## 安装MindSpore Hub
+
+当您想要快速体验MindSpore预训练模型时，可以选装MindSpore Hub。
+
+具体安装步骤参见[MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README_CN.md)。
diff --git a/install/mindspore_gpu_install_source_en.md b/install/mindspore_gpu_install_source_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..ea9f80cef2bad328cc833dac93b0f4d8bda50015
--- /dev/null
+++ b/install/mindspore_gpu_install_source_en.md
@@ -0,0 +1,147 @@
+# Installing MindSpore in GPU by Source Code
+
+
+
+- [Installing MindSpore in GPU by Source Code](#installing-mindspore-in-gpu-by-source-code)
+ - [System Environment Information Confirmation](#system-environment-information-confirmation)
+ - [Downloading Source Code from Code Repository](#downloading-source-code-from-code-repository)
+ - [Compiling MindSpore](#compiling-mindspore)
+ - [Installing MindSpore](#installing-mindspore)
+ - [Installation Verification](#installation-verification)
+ - [Installing MindInsight](#installing-mindinsight)
+ - [Installing MindArmour](#installing-mindarmour)
+ - [Installing MindSpore Hub](#installing-mindspore-hub)
+
+
+
+
+
+This document describes how to quickly install MindSpore by source code in a Linux system with a GPU environment.
+
+## System Environment Information Confirmation
+
+- Confirm that Ubuntu 18.04 is installed with 64-bit operating system.
+- Confirm that [GCC 7.3.0](http://ftp.gnu.org/gnu/gcc/gcc-7.3.0/gcc-7.3.0.tar.gz) is installed.
+- Confirm that [gmp 6.1.2](https://gmplib.org/download/gmp/gmp-6.1.2.tar.xz) is installed.
+- Confirm that [Python 3.7.5](https://www.python.org/ftp/python/3.7.5/Python-3.7.5.tgz) is installed.
+- Confirm that [CMake 3.18.3 or later](https://cmake.org/download/) is installed.
+ - After installing, add the path of `cmake` to the environment variable PATH.
+- Confirm that [patch 2.5 or later](http://ftp.gnu.org/gnu/patch/) is installed.
+ - After installing, add the path of `patch` to the environment variable PATH.
+- Confirm that [Autoconf 2.69 or later](https://www.gnu.org/software/autoconf) is installed. (Default versions of these tools built in their systems are supported.)
+- Confirm that [Libtool 2.4.6-29.fc30 or later](https://www.gnu.org/software/libtool) is installed. (Default versions of these tools built in their systems are supported.)
+- Confirm that [Automake 1.15.1 or later](https://www.gnu.org/software/automake) is installed.(Default versions of these tools built in their systems are supported.)
+- Confirm that [cuDNN 7.6 or later](https://developer.nvidia.com/rdp/cudnn-archive) is installed.
+- Confirm that [Flex 2.5.35 or later](https://github.com/westes/flex/) is installed.
+- Confirm that [wheel 0.32.0 or later](https://pypi.org/project/wheel/) is installed.
+- Confirm that [OpenSSL 1.1.1 or later](https://github.com/openssl/openssl.git) is installed.
+ - ensure that [OpenSSL](https://github.com/openssl/openssl) is installed and set system variable `export OPENSSL_ROOT_DIR="OpenSSL installation directory"`.
+- Confirm that [CUDA 10.1](https://developer.nvidia.com/cuda-10.1-download-archive-base) is installed as default configuration.
+ - If CUDA is installed in a non-default path, after installing CUDA, environment variable `PATH`(e.g. `export PATH=/usr/local/cuda-${version}/bin:$PATH`) and `LD_LIBRARY_PATH`(e.g. `export LD_LIBRARY_PATH=/usr/local/cuda-${version}/lib64:$LD_LIBRARY_PATH`) need to be set. Please refer to [CUDA installation guide](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/index.html#post-installation-actions) for detailed post installation actions.
+- Confirm that [OpenMPI 3.1.5](https://www.open-mpi.org/faq/?category=building#easy-build) is installed. (optional, required for single-node/multi-GPU and multi-node/multi-GPU training)
+- Confirm that [NCCL 2.7.6-1](https://docs.nvidia.com/deeplearning/sdk/nccl-install-guide/index.html#debian) is installed. (optional, required for single-node/multi-GPU and multi-node/multi-GPU training)
+- Confirm that the git tool is installed.
+ If not, use the following command to install it:
+
+ ```bash
+ apt-get install git
+ ```
+
+## Downloading Source Code from Code Repository
+
+```bash
+git clone https://gitee.com/mindspore/mindspore.git -b r1.0
+```
+
+## Compiling MindSpore
+
+Run the following command in the root directory of the source code to compile MindSpore:
+
+```bash
+bash build.sh -e gpu
+```
+
+Of which,
+
+- In the `build.sh` script, the default number of compilation threads is 8. If the compiler performance is poor, compilation errors may occur. You can add -j{Number of threads} in to script to reduce the number of threads. For example, `bash build.sh -e ascend -j4`.
+
+## Installing MindSpore
+
+```bash
+chmod +x build/package/mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl
+pip install build/package/mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+Of which,
+
+- When the network is connected, dependency items are automatically downloaded during .whl package installation. (For details about other dependency items, see [requirements.txt](https://gitee.com/mindspore/mindspore/blob/r1.0/requirements.txt)). In other cases, you need to manually install dependency items.
+- `{version}` denotes the version of MindSpore. For example, when you are downloading MindSpore 1.0.1, `{version}` should be 1.0.1.
+- `{arch}` denotes the system architecture. For example, the Linux system you are using is x86 architecture 64-bit, `{arch}` should be `x86_64`. If the system is ARM architecture 64-bit, then it should be `aarch64`.
+
+## Installation Verification
+
+```python
+import numpy as np
+from mindspore import Tensor
+import mindspore.ops as ops
+import mindspore.context as context
+
+context.set_context(device_target="GPU")
+x = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+y = Tensor(np.ones([1,3,3,4]).astype(np.float32))
+print(ops.tensor_add(x, y))
+```
+
+- The outputs should be the same as:
+
+```text
+[[[ 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.]]]
+```
+
+It means MindSpore has been installed successfully.
+
+## Version Update
+
+Using the following command if you need update MindSpore version.
+
+- Update online
+
+ ```bash
+ pip install --upgrade mindspore-gpu
+ ```
+
+- Update after source code compilation
+
+ After successfully executing the compile script `build.sh` in the root path of the source code, find the `whl` package in path `build/package`, use the following command to update your version.
+
+ ```bash
+ pip install --upgrade mindspore_gpu-{version}-cp37-cp37m-linux_{arch}.whl
+ ```
+
+## Installing MindInsight
+
+If you need to analyze information such as model scalars, graphs, computation graphs and model traceback, you can install MindInsight.
+
+For more details, please refer to [MindInsight](https://gitee.com/mindspore/mindinsight/blob/master/README.md).
+
+## Installing MindArmour
+
+If you need to conduct AI model security research or enhance the security of the model in you applications, you can install MindArmour.
+
+For more details, please refer to [MindArmour](https://gitee.com/mindspore/mindarmour/blob/master/README.md).
+
+## Installing MindSpore Hub
+
+If you need to access and experience MindSpore pre-trained models quickly, you can install MindSpore Hub.
+
+For more details, please refer to [MindSpore Hub](https://gitee.com/mindspore/hub/blob/master/README.md).
diff --git a/lite/docs/source_en/_static/logo_source.png b/lite/docs/source_en/_static/logo_source.png
deleted file mode 100644
index fc347d271abe082ae8d16242328551648766b6fb..0000000000000000000000000000000000000000
Binary files a/lite/docs/source_en/_static/logo_source.png and /dev/null differ
diff --git a/lite/docs/source_en/apicc/apicc.rst b/lite/docs/source_en/apicc/apicc.rst
deleted file mode 100644
index 82bbf145ca283f9d79be97c93986fcf03d9e2aed..0000000000000000000000000000000000000000
--- a/lite/docs/source_en/apicc/apicc.rst
+++ /dev/null
@@ -1,12 +0,0 @@
-C++ API
-=======
-
-.. toctree::
- :maxdepth: 1
-
- class_list
- lite
- session
- tensor
- dataset
- errorcode_and_metatype
\ No newline at end of file
diff --git a/lite/docs/source_en/apicc/class_list.md b/lite/docs/source_en/apicc/class_list.md
deleted file mode 100644
index bf0acb8f57c2702e3da3ef89d0fb23e723add840..0000000000000000000000000000000000000000
--- a/lite/docs/source_en/apicc/class_list.md
+++ /dev/null
@@ -1,16 +0,0 @@
-# Class List
-
-Here is a list of all classes with links to the namespace documentation for each member:
-
-| Namespace | Class Name | Description |
-| --- | --- | --- |
-| mindspore::lite | [Allocator](https://www.mindspore.cn/lite/docs/en/master/apicc/lite.html#allocator) | Allocator defines a memory pool for dynamic memory malloc and memory free. |
-| mindspore::lite | [Context](https://www.mindspore.cn/lite/docs/en/master/apicc/lite.html#context) | Context defines for holding environment variables during runtime. |
-| mindspore::lite | [ModelImpl](https://www.mindspore.cn/lite/docs/en/master/apicc/lite.html#modelimpl) | ModelImpl defines the implement class of Model in MindSpore Lite. |
-| mindspore::lite | [PrimitiveC](https://www.mindspore.cn/lite/docs/en/master/apicc/lite.html#primitivec) | Primitive defines as prototype of operator. |
-| mindspore::lite | [Model](https://www.mindspore.cn/lite/docs/en/master/apicc/lite.html#model) | Model defines model in MindSpore Lite for managing graph. |
-| mindspore::lite | [ModelBuilder](https://www.mindspore.cn/lite/docs/en/master/apicc/lite.html#modelbuilder) | ModelBuilder is defined to build the model. |
-| mindspore::session | [LiteSession](https://www.mindspore.cn/lite/docs/en/master/apicc/session.html#litesession) | LiteSession defines session in MindSpore Lite for compiling Model and forwarding model. |
-| mindspore::tensor | [MSTensor](https://www.mindspore.cn/lite/docs/en/master/apicc/tensor.html#mstensor) | MSTensor defines tensor in MindSpore Lite. |
-| mindspore::dataset | [LiteMat](https://www.mindspore.cn/lite/docs/en/master/apicc/dataset.html#litemat) |Class that represents a LiteMat of a Image. |
-
diff --git a/lite/docs/source_en/glossary.md b/lite/docs/source_en/glossary.md
deleted file mode 100644
index 8b596229292567ddb8b24b7a0cc1560c763f224d..0000000000000000000000000000000000000000
--- a/lite/docs/source_en/glossary.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Glossary
-
-
-
-| Acronym and Abbreviation | Description |
-| ----- | ----- |
-| MindSpore Lite | MindSpore AI engine is applied to the intelligent terminal and resource constrained scenes on the edge side. |
-| MindSpore Micro | MindSpore AI engine with smaller package size for IOT devices. |
-| GHLO | Graph high-level optimization. |
-| GLLO | Graph low-level optimization. |
-| RT | Runtime. |
-
diff --git a/lite/docs/source_en/operator_list.md b/lite/docs/source_en/operator_list.md
deleted file mode 100644
index 6038b5c95690dd4b30378a7101d828ef9d0cda90..0000000000000000000000000000000000000000
--- a/lite/docs/source_en/operator_list.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# Operator List
-
-
-
-> √ The checked items are the operators supported by MindSpore Lite。
-
-| Operation | CPU
-
-| 术语/缩略语 | 说明 |
-| ----- | ----- |
-| MindSpore Lite | 应用在智能终端，边缘册资源受限场景的MindSpore AI 引擎。 |
-| MindSpore Micro | 应用在IoT设备的，包大小更小的MindSpore AI引擎。 |
-| GHLO | Graph high-level optimization，图高层优化。 |
-| GLLO | Graph low-level optimization，图底层优化。 |
-| RT | Runtime运行时。 |
-
diff --git a/lite/docs/source_zh_cn/operator_list.md b/lite/docs/source_zh_cn/operator_list.md
deleted file mode 100644
index 3384d8baf91b1af92ff4758816790af7b6e241bc..0000000000000000000000000000000000000000
--- a/lite/docs/source_zh_cn/operator_list.md
+++ /dev/null
@@ -1,111 +0,0 @@
-# 算子支持
-
-
-
-> √勾选的项为MindSpore Lite所支持的算子。
-
-| 操作名 | CPU
+
+## 1.0.1
+
+### Releasenotes
+
+
+
+## 1.0.1
+
+### 版本说明
+
+