From edf87c576ec4598167bd87604cc53abada1ec5b3 Mon Sep 17 00:00:00 2001 From: zhangxinfeng3 Date: Thu, 11 Mar 2021 10:38:34 +0800 Subject: [PATCH 01/79] add sponge operators --- .../source_en/mindspore/operations.rst | 37 +++++++++++++++++++ .../source_zh_cn/mindspore/operations.rst | 37 +++++++++++++++++++ .../apply_deep_probability_programming.md | 2 +- 3 files changed, 75 insertions(+), 1 deletion(-) diff --git a/docs/api_python/source_en/mindspore/operations.rst b/docs/api_python/source_en/mindspore/operations.rst index fc34a7e9c7..c3c0555636 100644 --- a/docs/api_python/source_en/mindspore/operations.rst +++ b/docs/api_python/source_en/mindspore/operations.rst @@ -345,6 +345,43 @@ Random Operators mindspore.ops.UniformInt mindspore.ops.UniformReal +Sponge Operators +^^^^^^^^^^^^^^^^ + +.. msplatformautosummary:: + :toctree: ops + :nosignatures: + :template: classtemplate.rst + + mindspore.ops.AngleAtomEnergy + mindspore.ops.AngleEnergy + mindspore.ops.AngleForce + mindspore.ops.AngleForceWithAtomEnergy + mindspore.ops.BondAtomEnergy + mindspore.ops.BondEnergy + mindspore.ops.BondForce + mindspore.ops.BondForceWithAtomEnergy + mindspore.ops.BondForceWithAtomVirial + mindspore.ops.DihedralAtomEnergy + mindspore.ops.DihedralEnergy + mindspore.ops.DihedralForce + mindspore.ops.DihedralForceWithAtomEnergy + mindspore.ops.Dihedral14CFAtomEnergy + mindspore.ops.Dihedral14CFEnergy + mindspore.ops.Dihedral14LJAtomEnergy + mindspore.ops.Dihedral14LJCFForceWithAtomEnergy + mindspore.ops.Dihedral14LJEnergy + mindspore.ops.Dihedral14LJForce + mindspore.ops.Dihedral14LJForceWithDirectCF + mindspore.ops.LJEnergy + mindspore.ops.LJForce + mindspore.ops.LJForceWithPMEDirectForce + mindspore.ops.MDIterationLeapFrog + mindspore.ops.NeighborListUpdate + mindspore.ops.PMEEnergy + mindspore.ops.PMEExcludedForce + mindspore.ops.PMEReciprocalForce + Inner Operators ^^^^^^^^^^^^^^^^ diff --git a/docs/api_python/source_zh_cn/mindspore/operations.rst b/docs/api_python/source_zh_cn/mindspore/operations.rst index fc34a7e9c7..c3c0555636 100644 --- a/docs/api_python/source_zh_cn/mindspore/operations.rst +++ b/docs/api_python/source_zh_cn/mindspore/operations.rst @@ -345,6 +345,43 @@ Random Operators mindspore.ops.UniformInt mindspore.ops.UniformReal +Sponge Operators +^^^^^^^^^^^^^^^^ + +.. msplatformautosummary:: + :toctree: ops + :nosignatures: + :template: classtemplate.rst + + mindspore.ops.AngleAtomEnergy + mindspore.ops.AngleEnergy + mindspore.ops.AngleForce + mindspore.ops.AngleForceWithAtomEnergy + mindspore.ops.BondAtomEnergy + mindspore.ops.BondEnergy + mindspore.ops.BondForce + mindspore.ops.BondForceWithAtomEnergy + mindspore.ops.BondForceWithAtomVirial + mindspore.ops.DihedralAtomEnergy + mindspore.ops.DihedralEnergy + mindspore.ops.DihedralForce + mindspore.ops.DihedralForceWithAtomEnergy + mindspore.ops.Dihedral14CFAtomEnergy + mindspore.ops.Dihedral14CFEnergy + mindspore.ops.Dihedral14LJAtomEnergy + mindspore.ops.Dihedral14LJCFForceWithAtomEnergy + mindspore.ops.Dihedral14LJEnergy + mindspore.ops.Dihedral14LJForce + mindspore.ops.Dihedral14LJForceWithDirectCF + mindspore.ops.LJEnergy + mindspore.ops.LJForce + mindspore.ops.LJForceWithPMEDirectForce + mindspore.ops.MDIterationLeapFrog + mindspore.ops.NeighborListUpdate + mindspore.ops.PMEEnergy + mindspore.ops.PMEExcludedForce + mindspore.ops.PMEReciprocalForce + Inner Operators ^^^^^^^^^^^^^^^^ diff --git a/tutorials/training/source_zh_cn/advanced_use/apply_deep_probability_programming.md b/tutorials/training/source_zh_cn/advanced_use/apply_deep_probability_programming.md index 6186799419..7715b364d9 100644 --- a/tutorials/training/source_zh_cn/advanced_use/apply_deep_probability_programming.md +++ b/tutorials/training/source_zh_cn/advanced_use/apply_deep_probability_programming.md @@ -628,7 +628,7 @@ LeNet5 - 偶然不确定性（Aleatoric Uncertainty）：描述数据中的内在噪声，即无法避免的误差，这个现象不能通过增加采样数据来削弱。 - 认知不确定性（Epistemic Uncertainty）：模型自身对输入数据的估计可能因为训练不佳、训练数据不够等原因而不准确，可以通过增加训练数据等方式来缓解。 -不确定性估计工具箱，适用于主流的深度学习模型，如回归、分类等。在推理阶段，利用不确定性估计工具箱，开发人员只需通过训练模型和训练数据集，指定需要估计的任务和样本，即可得到任意不确定性和认知不确定性。基于不确定性信息，开发人员可以更好地理解模型和数据集。 +不确定性估计工具箱，适用于主流的深度学习模型，如回归、分类等。在推理阶段，利用不确定性估计工具箱，开发人员只需通过训练模型和训练数据集，指定需要估计的任务和样本，即可得到偶然不确定性和认知不确定性。基于不确定性信息，开发人员可以更好地理解模型和数据集。 > 本例面向GPU或Ascend 910 AI处理器平台，你可以在这里下载完整的样例代码： 以分类任务为例，本例中使用的模型是LeNet，数据集为MNIST，数据处理过程与教程中的[实现一个图片分类应用](https://www.mindspore.cn/tutorial/training/zh-CN/master/quick_start/quick_start.html)一致。为了评估测试示例的不确定性，使用工具箱的方法如下: -- Gitee From 1981aa689042850c4df9297c7f7e63144515b153 Mon Sep 17 00:00:00 2001 From: zhangyi Date: Tue, 16 Mar 2021 19:17:15 +0800 Subject: [PATCH 02/79] modefy datasets of cifar10 for notebook. --- .../source_zh_cn/dataset_conversion.ipynb | 35 +++- .../source_zh_cn/dataset_loading.ipynb | 19 +- .../source_zh_cn/sampler.ipynb | 25 +-- .../multi_platform_inference_ascend_310.rst | 2 +- .../multi_platform_inference_ascend_310.rst | 2 +- .../quick_start/quick_start_codegen.md | 118 ++++++------ ...indspore_computer_vision_application.ipynb | 100 ++++------- .../mindspore_enable_auto_augmentation.ipynb | 58 +++--- .../notebook/mindspore_mixed_precision.ipynb | 110 ++++-------- .../optimize_data_processing.ipynb | 169 +++++++++++++----- 10 files changed, 330 insertions(+), 308 deletions(-) diff --git a/docs/programming_guide/source_zh_cn/dataset_conversion.ipynb b/docs/programming_guide/source_zh_cn/dataset_conversion.ipynb index 18efa450d1..06fe3fed89 100644 --- a/docs/programming_guide/source_zh_cn/dataset_conversion.ipynb +++ b/docs/programming_guide/source_zh_cn/dataset_conversion.ipynb @@ -41,7 +41,14 @@ }, "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ] + } + ], "source": [ "from io import BytesIO\n", "import os\n", @@ -342,7 +349,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "./datasets/cifar-10-batches-py/\n", + "./datasets/cifar-10-batches-py\n", "├── batches.meta\n", "├── data_batch_1\n", "├── data_batch_2\n", @@ -357,9 +364,10 @@ } ], "source": [ - "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10-py.zip\n", - "!unzip -o cifar10-py.zip -d ./datasets\n", - "!tree ./datasets/cifar-10-batches-py/" + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-python.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-python.tar.gz -C datasets\n", + "!tree ./datasets/cifar-10-batches-py" ] }, { @@ -654,7 +662,18 @@ "cell_type": "code", "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "os.system('pip install tensorflow') if os.system('python -c \"import tensorflow\"') else print(\"TensorFlow installed\")" ] @@ -840,9 +859,9 @@ ], "metadata": { "kernelspec": { - "display_name": "MindSpore-1.0.1", + "display_name": "MindSpore-1.1.1", "language": "python", - "name": "mindspore-1.0.1" + "name": "mindspore-1.1.1" }, "language_info": { "codemirror_mode": { diff --git a/docs/programming_guide/source_zh_cn/dataset_loading.ipynb b/docs/programming_guide/source_zh_cn/dataset_loading.ipynb index 86f1f350b4..0bc0762839 100644 --- a/docs/programming_guide/source_zh_cn/dataset_loading.ipynb +++ b/docs/programming_guide/source_zh_cn/dataset_loading.ipynb @@ -70,7 +70,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "./datasets/cifar10/\n", + "./datasets/cifar-10-batches-bin\n", + "├── readme.html\n", "├── test\n", "│   └── test_batch.bin\n", "└── train\n", @@ -81,14 +82,18 @@ " ├── data_batch_4.bin\n", " └── data_batch_5.bin\n", "\n", - "2 directories, 7 files\n" + "2 directories, 8 files\n" ] } ], "source": [ - "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "!unzip -o ./cifar10.zip -d ./datasets/\n", - "!tree ./datasets/cifar10/" + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-binary.tar.gz -C datasets\n", + "!mkdir -p datasets/cifar-10-batches-bin/train datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/test_batch.bin datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/data_batch*.bin datasets/cifar-10-batches-bin/batches.meta.txt datasets/cifar-10-batches-bin/train\n", + "!tree ./datasets/cifar-10-batches-bin" ] }, { @@ -120,7 +125,7 @@ "source": [ "import mindspore.dataset as ds\n", "\n", - "DATA_DIR = \"./datasets/cifar10/train/\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train/\"\n", "\n", "sampler = ds.SequentialSampler(num_samples=5)\n", "dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)\n", @@ -976,4 +981,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/docs/programming_guide/source_zh_cn/sampler.ipynb b/docs/programming_guide/source_zh_cn/sampler.ipynb index 756295600d..24fd0c6d48 100644 --- a/docs/programming_guide/source_zh_cn/sampler.ipynb +++ b/docs/programming_guide/source_zh_cn/sampler.ipynb @@ -53,7 +53,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "./datasets/cifar10\n", + "./datasets/cifar-10-batches-bin\n", + "├── readme.html\n", "├── test\n", "│   └── test_batch.bin\n", "└── train\n", @@ -64,14 +65,18 @@ " ├── data_batch_4.bin\n", " └── data_batch_5.bin\n", "\n", - "2 directories, 7 files\n" + "2 directories, 8 files\n" ] } ], "source": [ - "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "!unzip -o cifar10.zip -d ./datasets\n", - "!tree ./datasets/cifar10" + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-binary.tar.gz -C datasets\n", + "!mkdir -p datasets/cifar-10-batches-bin/train datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/test_batch.bin datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/data_batch*.bin datasets/cifar-10-batches-bin/batches.meta.txt datasets/cifar-10-batches-bin/train\n", + "!tree ./datasets/cifar-10-batches-bin" ] }, { @@ -114,7 +119,7 @@ "\n", "ds.config.set_seed(0)\n", "\n", - "DATA_DIR = \"./datasets/cifar10/train/\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train/\"\n", "\n", "print(\"------ Without Replacement ------\")\n", "\n", @@ -167,7 +172,7 @@ "\n", "ds.config.set_seed(1)\n", "\n", - "DATA_DIR = \"./datasets/cifar10/train/\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train/\"\n", "\n", "weights = [1, 1, 0, 0, 0, 0, 0, 0, 0, 0]\n", "sampler = ds.WeightedRandomSampler(weights, num_samples=6)\n", @@ -208,7 +213,7 @@ "\n", "ds.config.set_seed(2)\n", "\n", - "DATA_DIR = \"./datasets/cifar10/train/\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train/\"\n", "\n", "indices = [0, 1, 2, 3, 4, 5]\n", "sampler = ds.SubsetRandomSampler(indices, num_samples=3)\n", @@ -266,7 +271,7 @@ "\n", "ds.config.set_seed(3)\n", "\n", - "DATA_DIR = \"./datasets/cifar10/train/\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train/\"\n", "\n", "sampler = ds.PKSampler(num_val=2, class_column='label', num_samples=20)\n", "dataset = ds.Cifar10Dataset(DATA_DIR, sampler=sampler)\n", @@ -350,7 +355,7 @@ " for i in range(0, 10, 2):\n", " yield i\n", "\n", - "DATA_DIR = \"./datasets/cifar10/train/\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train/\"\n", "\n", "dataset = ds.Cifar10Dataset(DATA_DIR, sampler=MySampler())\n", "\n", diff --git a/tutorials/inference/source_en/multi_platform_inference_ascend_310.rst b/tutorials/inference/source_en/multi_platform_inference_ascend_310.rst index 1544dd6a23..bdc80ec067 100644 --- a/tutorials/inference/source_en/multi_platform_inference_ascend_310.rst +++ b/tutorials/inference/source_en/multi_platform_inference_ascend_310.rst @@ -4,5 +4,5 @@ Inference on Ascend 310 .. toctree:: :maxdepth: 1 + multi_platform_inference_ascend_310_mindir multi_platform_inference_ascend_310_air - multi_platform_inference_ascend_310_mindir \ No newline at end of file diff --git a/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310.rst b/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310.rst index 6a0e36fc71..5c5ac28263 100644 --- a/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310.rst +++ b/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310.rst @@ -4,5 +4,5 @@ Ascend 310 AI处理器上推理 .. toctree:: :maxdepth: 1 + multi_platform_inference_ascend_310_mindir multi_platform_inference_ascend_310_air - multi_platform_inference_ascend_310_mindir \ No newline at end of file diff --git a/tutorials/lite/source_zh_cn/quick_start/quick_start_codegen.md b/tutorials/lite/source_zh_cn/quick_start/quick_start_codegen.md index f8fa35ffeb..7d5ef1743f 100644 --- a/tutorials/lite/source_zh_cn/quick_start/quick_start_codegen.md +++ b/tutorials/lite/source_zh_cn/quick_start/quick_start_codegen.md @@ -71,7 +71,7 @@ bash mnist.sh 推理结果如下： -```txt +```text input 0: mnist_input.bin 51, 52, 68, 78, 78, 88, 75, 87, 68, 61, 51, 56, 63, 55, 66, 61, 56, 71, 57, 73, mnist inference success. @@ -83,93 +83,93 @@ mnist inference success. 1. 算子静态库目录说明 -在编译此工程之前需要预先获取x86平台对应的算子库[codegen](https://www.mindspore.cn/tutorial/lite/zh-CN/master/use/downloads.html)，解压后得到operator_library，将其拷贝到当前目录下。 + 在编译此工程之前需要预先获取x86平台对应的算子库[codegen](https://www.mindspore.cn/tutorial/lite/zh-CN/master/use/downloads.html)，解压后得到operator_library，将其拷贝到当前目录下。 -以本教程为例，预置x86平台算子静态库的目录如下： + 以本教程为例，预置x86平台算子静态库的目录如下： -```txt -├── operator_library # 对应平台算子库目录 - ├── include # 对应平台算子库头文件目录 - └── lib # 对应平台算子库静态库目录 -``` + ```text + ├── operator_library # 对应平台算子库目录 + ├── include # 对应平台算子库头文件目录 + └── lib # 对应平台算子库静态库目录 + ``` 2. 生成代码工程目录说明 -当前目录下预置了MNIST分类网络生成的代码。 + 当前目录下预置了MNIST分类网络生成的代码。 -```txt -├── mnist # 生成代码的根目录 - ├── benchmark # 生成代码的benchmark目录 - └── src # 模型推理代码目录 -``` + ```text + ├── mnist # 生成代码的根目录 + ├── benchmark # 生成代码的benchmark目录 + └── src # 模型推理代码目录 + ``` #### 代码编译 1. 编译生成模型静态库 -组织模型生成的推理代码以及算子静态库，编译生成模型推理静态库。 + 组织模型生成的推理代码以及算子静态库，编译生成模型推理静态库。 -进入代码工程src目录下并新建build目录： + 进入代码工程src目录下并新建build目录： -```bash -cd mnist/src && mkdir build -``` + ```bash + cd mnist/src && mkdir build + ``` -进入build目录： + 进入build目录： -```bash -cd build -``` + ```bash + cd build + ``` -开始编译： + 开始编译： -```bash -cmake -DOP_LIB={path to}/operator_library/lib/x86/liboplib.a \ - -DOP_HEADER_PATH={path to}/operator_library/include/ \ - .. -make -``` + ```bash + cmake -DOP_LIB={path to}/operator_library/lib/x86/liboplib.a \ + -DOP_HEADER_PATH={path to}/operator_library/include/ \ + .. + make + ``` -> {path to}需要用户根据实际情况填写。 + > {path to}需要用户根据实际情况填写。 -代码工程编译成功结果： + 代码工程编译成功结果： -```txt -[100%] Linking C static library libmnist.a -unzip raw static library libmnist.a -raw static library libmnist.a size: --rw-r--r-- 1 root root 356K Mar 4 16:48 libmnist.a -generate specified static library libmnist.a -new static library libmnist.a size: --rw-r--r-- 1 root root 735K Mar 4 16:48 libmnist.a -``` + ```text + [100%] Linking C static library libmnist.a + unzip raw static library libmnist.a + raw static library libmnist.a size: + -rw-r--r-- 1 root root 356K Mar 4 16:48 libmnist.a + generate specified static library libmnist.a + new static library libmnist.a size: + -rw-r--r-- 1 root root 735K Mar 4 16:48 libmnist.a + ``` -此时在mnist/src/build目录下生成了libmnist.a，推理执行库。 + 此时在mnist/src/build目录下生成了libmnist.a，推理执行库。 2. 编译生成可执行文件 -组织模型推理静态库以及benchmark代码，编译生成二进制可执行文件文件，进入mnist/benchmark目录并新建build目录： + 组织模型推理静态库以及benchmark代码，编译生成二进制可执行文件文件，进入mnist/benchmark目录并新建build目录： -```bash -cd mnist/benchmark && mkdir build -``` + ```bash + cd mnist/benchmark && mkdir build + ``` -进入build目录并编译： + 进入build目录并编译： -```bash -cd build -cmake -DMODEL_LIB=../../src/build/libmnist.a .. -make -``` + ```bash + cd build + cmake -DMODEL_LIB=../../src/build/libmnist.a .. + make + ``` - 代码工程编译成功结果： + 代码工程编译成功结果： -```txt -[100%] Linking C executable benchmark -[100%] Built target benchmark -``` + ```text + [100%] Linking C executable benchmark + [100%] Built target benchmark + ``` -此时在mnist/benchmark/build目录下生成了benchmark可执行文件。 + 此时在mnist/benchmark/build目录下生成了benchmark可执行文件。 #### 代码部署 @@ -182,7 +182,7 @@ make > mnist_input.bin在example/mnist目录下，mnist.net为模型参数文件，在example/mnist/src目录下。 生成结果如下： -```txt +```text input 0: mnist_input.bin 51, 52, 68, 78, 78, 88, 75, 87, 68, 61, 51, 56, 63, 55, 66, 61, 56, 71, 57, 73, mnist inference success. diff --git a/tutorials/notebook/mindspore_computer_vision_application.ipynb b/tutorials/notebook/mindspore_computer_vision_application.ipynb index 673b41422c..ea97cc1492 100644 --- a/tutorials/notebook/mindspore_computer_vision_application.ipynb +++ b/tutorials/notebook/mindspore_computer_vision_application.ipynb @@ -80,29 +80,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2020-12-04 11:34:20-- https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "Resolving proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)... 192.168.0.172\n", - "Connecting to proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)|192.168.0.172|:8083... connected.\n", - "Proxy request sent, awaiting response... 200 OK\n", - "Length: 166235630 (159M) [application/zip]\n", - "Saving to: ‘cifar10.zip’\n", - "\n", - "cifar10.zip 100%[===================>] 158.53M 56.2MB/s in 2.8s \n", - "\n", - "2020-12-04 11:34:23 (56.2 MB/s) - ‘cifar10.zip’ saved [166235630/166235630]\n", - "\n", - "Archive: cifar10.zip\n", - " creating: ./datasets/cifar10/\n", - " creating: ./datasets/cifar10/test/\n", - " inflating: ./datasets/cifar10/test/test_batch.bin \n", - " creating: ./datasets/cifar10/train/\n", - " inflating: ./datasets/cifar10/train/batches.meta.txt \n", - " inflating: ./datasets/cifar10/train/data_batch_1.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_2.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_3.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_4.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_5.bin \n", - "./datasets/cifar10\n", + "./datasets/cifar-10-batches-bin\n", + "├── readme.html\n", "├── test\n", "│   └── test_batch.bin\n", "└── train\n", @@ -113,14 +92,18 @@ " ├── data_batch_4.bin\n", " └── data_batch_5.bin\n", "\n", - "2 directories, 7 files\n" + "2 directories, 8 files\n" ] } ], "source": [ - "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "!unzip -o cifar10.zip -d ./datasets\n", - "!tree ./datasets/cifar10" + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-binary.tar.gz -C datasets\n", + "!mkdir -p datasets/cifar-10-batches-bin/train datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/test_batch.bin datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/data_batch*.bin datasets/cifar-10-batches-bin/batches.meta.txt datasets/cifar-10-batches-bin/train\n", + "!tree ./datasets/cifar-10-batches-bin" ] }, { @@ -161,7 +144,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -216,7 +199,7 @@ " return cifar_ds\n", "\n", "\n", - "ds_train_path = \"./datasets/cifar10/train/\"\n", + "ds_train_path = \"./datasets/cifar-10-batches-bin/train/\"\n", "dataset_show = create_dataset(ds_train_path)\n", "with open(ds_train_path+\"batches.meta.txt\",\"r\",encoding=\"utf-8\") as f:\n", " all_name = [name.replace(\"\\n\",\"\") for name in f.readlines()]\n", @@ -277,16 +260,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2020-12-04 11:34:29-- https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/source-codes/resnet.py\n", + "--2021-03-15 19:23:03-- https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/source-codes/resnet.py\n", "Resolving proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)... 192.168.0.172\n", "Connecting to proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)|192.168.0.172|:8083... connected.\n", "Proxy request sent, awaiting response... 200 OK\n", - "Length: 9533 (9.3K) [binary/octet-stream]\n", + "Length: 9521 (9.3K) [binary/octet-stream]\n", "Saving to: ‘resnet.py’\n", "\n", - "resnet.py 100%[===================>] 9.31K --.-KB/s in 0s \n", + "resnet.py 100%[===================>] 9.30K --.-KB/s in 0s \n", "\n", - "2020-12-04 11:34:29 (160 MB/s) - ‘resnet.py’ saved [9533/9533]\n", + "2021-03-15 19:23:03 (194 MB/s) - ‘resnet.py’ saved [9521/9521]\n", "\n" ] } @@ -373,33 +356,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "epoch: 1 step: 142, loss is 2.041043\n", - "epoch: 1 step: 284, loss is 1.7856436\n", - "epoch: 1 step: 426, loss is 1.5305918\n", - "epoch: 1 step: 568, loss is 1.7724597\n", - "epoch: 1 step: 710, loss is 1.3827077\n", - "epoch: 1 step: 852, loss is 1.2597129\n", - "epoch: 1 step: 994, loss is 1.7239776\n", - "epoch: 1 step: 1136, loss is 1.5275167\n", - "epoch: 1 step: 1278, loss is 1.5193802\n", - "epoch: 1 step: 1420, loss is 1.2839599\n", - "epoch: 1 step: 1562, loss is 1.2304927\n", - "epoch: 2 step: 142, loss is 1.3567938\n", - "epoch: 2 step: 284, loss is 0.9500004\n", - "epoch: 2 step: 426, loss is 1.022787\n", - "epoch: 2 step: 568, loss is 1.1582599\n", - "epoch: 2 step: 710, loss is 0.96332455\n", - "epoch: 2 step: 852, loss is 1.0251642\n", - "... ...\n", - "epoch: 10 step: 426, loss is 0.15948972\n", - "epoch: 10 step: 568, loss is 0.30928737\n", - "epoch: 10 step: 710, loss is 0.26390004\n", - "epoch: 10 step: 852, loss is 0.33643064\n", - "epoch: 10 step: 994, loss is 0.38283178\n", - "epoch: 10 step: 1136, loss is 0.26065817\n", - "epoch: 10 step: 1278, loss is 0.48519582\n", - "epoch: 10 step: 1420, loss is 0.43286812\n", - "epoch: 10 step: 1562, loss is 0.42926747\n" + "epoch: 1 step: 1562, loss is 0.91001683\n", + "epoch: 2 step: 1562, loss is 1.2816406\n", + "epoch: 3 step: 1562, loss is 0.9639759\n", + "epoch: 4 step: 1562, loss is 0.52665555\n", + "epoch: 5 step: 1562, loss is 0.47037172\n", + "epoch: 6 step: 1562, loss is 0.78620523\n", + "epoch: 7 step: 1562, loss is 0.63779867\n", + "epoch: 8 step: 1562, loss is 0.18493408\n", + "epoch: 9 step: 1562, loss is 0.33825904\n", + "epoch: 10 step: 1562, loss is 0.21595426\n" ] } ], @@ -414,7 +380,7 @@ "# As for train, users could use model.train\n", "\n", "epoch_size = 10\n", - "ds_train_path = \"./datasets/cifar10/train/\"\n", + "ds_train_path = \"./datasets/cifar-10-batches-bin/train/\"\n", "model_path = \"./models/ckpt/mindspore_vision_application/\"\n", "os.system('rm -f {0}*.ckpt {0}*.meta {0}*.pb'.format(model_path))\n", "\n", @@ -476,7 +442,7 @@ "source": [ "## 进行模型精度验证\n", "\n", - "调用`model.eval`得到最终精度数据约为0.80远高于0.5，准确度较高，验证得出模型是性能较优的。" + "调用`model.eval`得到最终精度数据约为0.76远高于0.5，准确度较高，验证得出模型是性能较优的。" ] }, { @@ -488,13 +454,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "result: {'acc': 0.8001802884615384}\n" + "result: {'acc': 0.7557091346153846}\n" ] } ], "source": [ "# As for evaluation, users could use model.eval\n", - "ds_eval_path = \"./datasets/cifar10/test/\"\n", + "ds_eval_path = \"./datasets/cifar-10-batches-bin/test/\"\n", "eval_dataset = create_dataset(ds_eval_path, do_train=False)\n", "res = model.eval(eval_dataset)\n", "print(\"result: \", res)" @@ -512,9 +478,9 @@ ], "metadata": { "kernelspec": { - "display_name": "MindSpore-1.0.1", + "display_name": "MindSpore-1.1.1", "language": "python", - "name": "mindspore-1.0.1" + "name": "mindspore-1.1.1" }, "language_info": { "codemirror_mode": { @@ -531,4 +497,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorials/notebook/mindspore_enable_auto_augmentation.ipynb b/tutorials/notebook/mindspore_enable_auto_augmentation.ipynb index 0212ce815a..0be698debb 100644 --- a/tutorials/notebook/mindspore_enable_auto_augmentation.ipynb +++ b/tutorials/notebook/mindspore_enable_auto_augmentation.ipynb @@ -97,29 +97,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2020-12-09 11:25:17-- https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "Resolving proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)... 192.168.0.172\n", - "Connecting to proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)|192.168.0.172|:8083... connected.\n", - "Proxy request sent, awaiting response... 200 OK\n", - "Length: 166235630 (159M) [application/zip]\n", - "Saving to: ‘cifar10.zip’\n", - "\n", - "cifar10.zip 100%[===================>] 158.53M 47.1MB/s in 3.4s \n", - "\n", - "2020-12-09 11:25:21 (47.1 MB/s) - ‘cifar10.zip’ saved [166235630/166235630]\n", - "\n", - "Archive: cifar10.zip\n", - " creating: ./datasets/cifar10/\n", - " creating: ./datasets/cifar10/test/\n", - " inflating: ./datasets/cifar10/test/test_batch.bin \n", - " creating: ./datasets/cifar10/train/\n", - " inflating: ./datasets/cifar10/train/batches.meta.txt \n", - " inflating: ./datasets/cifar10/train/data_batch_1.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_2.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_3.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_4.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_5.bin \n", - "./datasets/cifar10\n", + "./datasets/cifar-10-batches-bin\n", + "├── readme.html\n", "├── test\n", "│   └── test_batch.bin\n", "└── train\n", @@ -130,14 +109,18 @@ " ├── data_batch_4.bin\n", " └── data_batch_5.bin\n", "\n", - "2 directories, 7 files\n" + "2 directories, 8 files\n" ] } ], "source": [ - "! wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "! unzip -o cifar10.zip -d ./datasets\n", - "! tree ./datasets/cifar10" + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-binary.tar.gz -C datasets\n", + "!mkdir -p datasets/cifar-10-batches-bin/train datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/test_batch.bin datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/data_batch*.bin datasets/cifar-10-batches-bin/batches.meta.txt datasets/cifar-10-batches-bin/train\n", + "!tree ./datasets/cifar-10-batches-bin" ] }, { @@ -174,7 +157,14 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ] + } + ], "source": [ "from mindspore import dtype as mstype\n", "import mindspore.dataset as ds\n", @@ -400,7 +390,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -412,7 +402,7 @@ } ], "source": [ - "DATA_DIR = \"./datasets/cifar10/train\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train\"\n", "data = create_dataset(dataset_path=DATA_DIR, do_train=True, batch_size=5, shuffle=False, num_samples=5, policy=policy_list)\n", "\n", "epochs = 5\n", @@ -444,7 +434,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -456,7 +446,7 @@ } ], "source": [ - "DATA_DIR = \"./datasets/cifar10/train\"\n", + "DATA_DIR = \"./datasets/cifar-10-batches-bin/train\"\n", "data = create_dataset(dataset_path=DATA_DIR, do_train=True, batch_size=5, shuffle=False, num_samples=5, policy=cifar10_policy)\n", "\n", "epochs = 5\n", @@ -485,9 +475,9 @@ ], "metadata": { "kernelspec": { - "display_name": "MindSpore-1.0.1", + "display_name": "MindSpore-1.1.1", "language": "python", - "name": "mindspore-1.0.1" + "name": "mindspore-1.1.1" }, "language_info": { "codemirror_mode": { diff --git a/tutorials/notebook/mindspore_mixed_precision.ipynb b/tutorials/notebook/mindspore_mixed_precision.ipynb index ace5906e9f..fd19f5e6fd 100644 --- a/tutorials/notebook/mindspore_mixed_precision.ipynb +++ b/tutorials/notebook/mindspore_mixed_precision.ipynb @@ -88,7 +88,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "下载并解压数据集cifar10到指定位置。" + "下载并解压数据集CIFAR-10到指定位置。" ] }, { @@ -100,29 +100,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2020-12-16 15:37:40-- https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "Resolving proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)... 192.168.0.172\n", - "Connecting to proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)|192.168.0.172|:8083... connected.\n", - "Proxy request sent, awaiting response... 200 OK\n", - "Length: 166235630 (159M) [application/zip]\n", - "Saving to: ‘cifar10.zip’\n", - "\n", - "cifar10.zip 100%[===================>] 158.53M 154MB/s in 1.0s \n", - "\n", - "2020-12-16 15:37:41 (154 MB/s) - ‘cifar10.zip’ saved [166235630/166235630]\n", - "\n", - "Archive: cifar10.zip\n", - " creating: ./datasets/cifar10/\n", - " creating: ./datasets/cifar10/test/\n", - " inflating: ./datasets/cifar10/test/test_batch.bin \n", - " creating: ./datasets/cifar10/train/\n", - " inflating: ./datasets/cifar10/train/batches.meta.txt \n", - " inflating: ./datasets/cifar10/train/data_batch_1.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_2.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_3.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_4.bin \n", - " inflating: ./datasets/cifar10/train/data_batch_5.bin \n", - "./datasets/cifar10\n", + "./datasets/cifar-10-batches-bin\n", + "├── readme.html\n", "├── test\n", "│   └── test_batch.bin\n", "└── train\n", @@ -133,14 +112,18 @@ " ├── data_batch_4.bin\n", " └── data_batch_5.bin\n", "\n", - "2 directories, 7 files\n" + "2 directories, 8 files\n" ] } ], "source": [ - "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "!unzip -o cifar10.zip -d ./datasets\n", - "!tree ./datasets/cifar10" + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-binary.tar.gz -C datasets\n", + "!mkdir -p datasets/cifar-10-batches-bin/train datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/test_batch.bin datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/data_batch*.bin datasets/cifar-10-batches-bin/batches.meta.txt datasets/cifar-10-batches-bin/train\n", + "!tree ./datasets/cifar-10-batches-bin" ] }, { @@ -172,7 +155,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -188,7 +171,7 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "\n", - "train_path = \"./datasets/cifar10/train\"\n", + "train_path = \"./datasets/cifar-10-batches-bin/train\"\n", "ds_train = ds.Cifar10Dataset(train_path, num_parallel_workers=8, shuffle=True)\n", "print(\"the cifar dataset size is :\", ds_train.get_dataset_size())\n", "dict1 = ds_train.create_dict_iterator()\n", @@ -309,16 +292,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "--2020-12-16 15:37:46-- https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/source-codes/resnet.py\n", + "--2021-03-16 18:05:54-- https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/source-codes/resnet.py\n", "Resolving proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)... 192.168.0.172\n", "Connecting to proxy-notebook.modelarts-dev-proxy.com (proxy-notebook.modelarts-dev-proxy.com)|192.168.0.172|:8083... connected.\n", "Proxy request sent, awaiting response... 200 OK\n", - "Length: 9533 (9.3K) [binary/octet-stream]\n", + "Length: 9521 (9.3K) [binary/octet-stream]\n", "Saving to: ‘resnet.py’\n", "\n", - "resnet.py 100%[===================>] 9.31K --.-KB/s in 0s \n", + "resnet.py 100%[===================>] 9.30K --.-KB/s in 0s \n", "\n", - "2020-12-16 15:37:46 (169 MB/s) - ‘resnet.py’ saved [9533/9533]\n", + "2021-03-16 18:05:54 (126 MB/s) - ‘resnet.py’ saved [9521/9521]\n", "\n" ] } @@ -421,38 +404,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "epoch: 1 step: 1, loss is 2.3136287\n", - "23430.50193786621 ms\n", - "epoch: 1 step: 2, loss is 2.307624\n", - "58.97927284240723 ms\n", - "epoch: 1 step: 3, loss is 2.3061028\n", - "58.4864616394043 ms\n", - "... ...\n", - "epoch: 5 step: 1551, loss is 0.64406776\n", - "57.350873947143555 ms\n", - "epoch: 5 step: 1552, loss is 0.71218234\n", - "57.8157901763916 ms\n", - "epoch: 5 step: 1553, loss is 0.92978317\n", - "57.538747787475586 ms\n", - "epoch: 5 step: 1554, loss is 0.7753498\n", - "57.379961013793945 ms\n", - "epoch: 5 step: 1555, loss is 0.37733847\n", - "57.35301971435547 ms\n", - "epoch: 5 step: 1556, loss is 0.6176548\n", - "57.685136795043945 ms\n", - "epoch: 5 step: 1557, loss is 0.6364769\n", - "59.25607681274414 ms\n", - "epoch: 5 step: 1558, loss is 0.9768918\n", - "58.919668197631836 ms\n", - "epoch: 5 step: 1559, loss is 0.6273656\n", - "59.133052825927734 ms\n", - "epoch: 5 step: 1560, loss is 0.59349436\n", - "57.468414306640625 ms\n", - "epoch: 5 step: 1561, loss is 0.87086564\n", - "57.49654769897461 ms\n", - "epoch: 5 step: 1562, loss is 0.95843387\n", - "56.33831024169922 ms\n", - "Epoch time: 95750.256, per step time: 61.300\n" + "epoch: 1 step: 1562, loss is 0.907213\n", + "473624.29022789 ms\n", + "epoch time: 510142.338 ms, per step time: 326.596 ms\n", + "epoch: 2 step: 1562, loss is 1.1226461\n", + "456184.42153930664 ms\n", + "epoch time: 456187.154 ms, per step time: 292.053 ms\n", + "epoch: 3 step: 1562, loss is 0.76163876\n", + "456118.32642555237 ms\n", + "epoch time: 456120.763 ms, per step time: 292.011 ms\n", + "epoch: 4 step: 1562, loss is 0.68869615\n", + "456123.6324310303 ms\n", + "epoch time: 456126.046 ms, per step time: 292.014 ms\n", + "epoch: 5 step: 1562, loss is 0.8315078\n", + "456153.0604362488 ms\n", + "epoch time: 456155.529 ms, per step time: 292.033 ms\n" ] } ], @@ -475,7 +441,7 @@ " model_path= \"./models/ckpt/mindspore_mixed_precision\"\n", " batch_size = 32\n", " epoch_size = 5\n", - " ds_train_path = \"./datasets/cifar10/train\"\n", + " ds_train_path = \"./datasets/cifar-10-batches-bin/train\"\n", " \n", " # clean up old run files before in Linux\n", " os.system('rm -f {0}*.ckpt {0}*.meta {0}*.pb'.format(model_path))\n", @@ -530,13 +496,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: {'acc': 0.7717347756410257}\n" + "Accuracy: {'acc': 0.7505008012820513}\n" ] } ], "source": [ "# Eval model\n", - "eval_dataset_path = \"./datasets/cifar10/test\"\n", + "eval_dataset_path = \"./datasets/cifar-10-batches-bin/test\"\n", "eval_data = create_dataset(eval_dataset_path,do_train=False)\n", "acc = model.eval(eval_data,dataset_sink_mode=True)\n", "print(\"Accuracy:\",acc)" @@ -597,9 +563,9 @@ ], "metadata": { "kernelspec": { - "display_name": "MindSpore-1.0.1", + "display_name": "MindSpore-1.1.1", "language": "python", - "name": "mindspore-1.0.1" + "name": "mindspore-1.1.1" }, "language_info": { "codemirror_mode": { @@ -616,4 +582,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorials/training/source_zh_cn/advanced_use/optimize_data_processing.ipynb b/tutorials/training/source_zh_cn/advanced_use/optimize_data_processing.ipynb index 3c13993965..acb956908a 100644 --- a/tutorials/training/source_zh_cn/advanced_use/optimize_data_processing.ipynb +++ b/tutorials/training/source_zh_cn/advanced_use/optimize_data_processing.ipynb @@ -61,7 +61,14 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ] + } + ], "source": [ "import mindspore.dataset as ds" ] @@ -95,7 +102,7 @@ "source": [ "运行以下命令来获取数据集：\n", "\n", - "下载CIFAR-10二进制格式数据集，并将数据集文件解压到`./datasets/cifar10`目录下，数据加载的时候使用该数据集。" + "下载CIFAR-10二进制格式数据集，并将数据集文件解压到`./datasets/`目录下，数据加载的时候使用该数据集。" ] }, { @@ -109,7 +116,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "./datasets/cifar10\n", + "./datasets/cifar-10-batches-bin\n", + "├── readme.html\n", "├── test\n", "│   └── test_batch.bin\n", "└── train\n", @@ -120,14 +128,18 @@ " ├── data_batch_4.bin\n", " └── data_batch_5.bin\n", "\n", - "2 directories, 7 files\n" + "2 directories, 8 files\n" ] } ], "source": [ - "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10.zip\n", - "!unzip -o cifar10.zip -d ./datasets\n", - "!tree ./datasets/cifar10" + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-binary.tar.gz -C datasets\n", + "!mkdir -p datasets/cifar-10-batches-bin/train datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/test_batch.bin datasets/cifar-10-batches-bin/test\n", + "!mv -f datasets/cifar-10-batches-bin/data_batch*.bin datasets/cifar-10-batches-bin/batches.meta.txt datasets/cifar-10-batches-bin/train\n", + "!tree ./datasets/cifar-10-batches-bin" ] }, { @@ -161,8 +173,9 @@ } ], "source": [ - "!wget -N https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/datasets/cifar10-py.zip\n", - "!unzip -o cifar10-py.zip -d ./datasets\n", + "!wget -N https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-python.tar.gz\n", + "!mkdir -p datasets\n", + "!tar -xzf cifar-10-python.tar.gz -C datasets\n", "!tree ./datasets/cifar-10-batches-py" ] }, @@ -238,25 +251,54 @@ "output_type": "stream", "text": [ "{'image': Tensor(shape=[32, 32, 3], dtype=UInt8, value=\n", - "[[[ 7, 7, 6],\n", - " [ 4, 4, 3],\n", - " [ 4, 4, 4],\n", + "[[[181, 185, 194],\n", + " [184, 187, 196],\n", + " [189, 192, 201],\n", + " ...\n", + " [178, 181, 191],\n", + " [171, 174, 183],\n", + " [166, 170, 179]],\n", + " [[182, 185, 194],\n", + " [184, 187, 196],\n", + " [189, 192, 201],\n", + " ...\n", + " [180, 183, 192],\n", + " [173, 176, 185],\n", + " [167, 170, 179]],\n", + " [[185, 188, 197],\n", + " [187, 190, 199],\n", + " [193, 196, 205],\n", " ...\n", - " [228, 228, 230],\n", - " [239, 239, 240],\n", - " [215, 215, 217]],\n", - " [[139, 137, 137],\n", - " [106, 101, 97],\n", - " [ 89, 81, 78],\n", + " [182, 185, 194],\n", + " [176, 179, 188],\n", + " [170, 173, 182]],\n", + " ...\n", + " [[176, 174, 185],\n", + " [172, 171, 181],\n", + " [174, 172, 183],\n", " ...\n", - " [216, 216, 219],\n", - " [216, 215, 218],\n", - " [197, 196, 199]]]), 'label': Tensor(shape=[], dtype=UInt32, value= 1)}\n" + " [168, 171, 180],\n", + " [164, 167, 176],\n", + " [160, 163, 172]],\n", + " [[172, 170, 181],\n", + " [171, 169, 180],\n", + " [173, 171, 182],\n", + " ...\n", + " [164, 167, 176],\n", + " [160, 163, 172],\n", + " [156, 159, 168]],\n", + " [[171, 169, 180],\n", + " [173, 171, 182],\n", + " [177, 175, 186],\n", + " ...\n", + " [162, 165, 174],\n", + " [158, 161, 170],\n", + " [152, 155, 164]]]), 'label': Tensor(shape=[], dtype=UInt32, value= 6)}\n" ] } ], "source": [ - "cifar10_path = \"./datasets/cifar10/train\"\n", + "cifar10_path = \"./datasets/cifar-10-batches-bin/train\"\n", "\n", "# create Cifar10Dataset for reading data\n", "cifar10_dataset = ds.Cifar10Dataset(cifar10_path,num_parallel_workers=4)\n", @@ -282,16 +324,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'data': Tensor(shape=[1280], dtype=UInt8, value= [255, 216, 255, 224, 0, 16, 74, 70, 73, 70, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 255, 219, 0, 67, \n", + "{'data': Tensor(shape=[1289], dtype=UInt8, value= [255, 216, 255, 224, 0, 16, 74, 70, 73, 70, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 255, 219, 0, 67, \n", " 0, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 2, 4, 3, 2, 2, 2, 2, 5, 4, \n", " 4, 3, 4, 6, 5, 6, 6, 6, 5, 6, 6, 6, 7, 9, 8, 6, 7, 9, 7, 6, 6, 8, 11, 8, \n", " 9, 10, 10, 10, 10, 10, 6, 8, 11, 12, 11, 10, 12, 9, 10, 10, 10, 255, 219, 0, 67, 1, 2, 2, \n", - " 2, 2, 2, 2, 5, 3, 3, 5, 10, 7, 6, 7, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, \n", - " ...\n", - " 17, 235, 119, 218, 84, 150, 235, 162, 253, 173, 5, 196, 218, 125, 149, 222, 103, 120, 23, 25, 249, 157, 209, 92, \n", - " 231, 31, 40, 36, 143, 74, 251, 95, 225, 207, 236, 217, 240, 67, 225, 45, 138, 203, 172, 75, 113, 107, 173, 70, \n", - " 81, 165, 58, 253, 188, 247, 55, 4, 177, 224, 70, 1, 40, 65, 250, 100, 87, 60, 177, 148, 249, 95, 50, 252, \n", - " 138, 157, 37, 165, 157, 207, 255, 217]), 'id': Tensor(shape=[], dtype=Int64, value= 21750), 'label': Tensor(shape=[], dtype=Int64, value= 2)}\n" + " ...\n", + " ...\n", + " ...\n", + " 39, 227, 206, 143, 241, 91, 196, 154, 230, 189, 125, 165, 105, 218, 94, 163, 124, 146, 11, 187, 29, 34, 217, 210, \n", + " 23, 186, 56, 14, 192, 19, 181, 1, 57, 36, 14, 51, 211, 173, 105, 9, 191, 100, 212, 174, 122, 25, 110, 39, \n", + " 11, 133, 193, 226, 169, 73, 36, 234, 69, 90, 222, 93, 31, 223, 115, 255, 217]), 'id': Tensor(shape=[], dtype=Int64, value= 46084), 'label': Tensor(shape=[], dtype=Int64, value= 5)}\n" ] } ], @@ -415,25 +457,54 @@ "output_type": "stream", "text": [ "{'image': Tensor(shape=[32, 32, 3], dtype=UInt8, value=\n", - "[[[ 17, 18, 27],\n", - " [ 21, 25, 27],\n", - " [ 36, 39, 29],\n", + "[[[213, 205, 194],\n", + " [215, 207, 196],\n", + " [219, 210, 200],\n", + " ...\n", + " [253, 254, 249],\n", + " [253, 254, 249],\n", + " [253, 254, 249]],\n", + " [[218, 208, 198],\n", + " [220, 210, 200],\n", + " [222, 212, 202],\n", + " ...\n", + " [253, 254, 249],\n", + " [253, 254, 249],\n", + " [253, 254, 249]],\n", + " [[219, 209, 198],\n", + " [222, 211, 200],\n", + " [224, 214, 202],\n", + " ...\n", + " [254, 253, 248],\n", + " [254, 253, 248],\n", + " [254, 253, 248]],\n", + " ...\n", + " [[135, 141, 139],\n", + " [135, 141, 139],\n", + " [146, 152, 150],\n", " ...\n", - " [ 50, 57, 23],\n", - " [ 49, 55, 21],\n", - " [ 54, 57, 23]],\n", - " [[ 40, 43, 13],\n", - " [ 41, 43, 19],\n", - " [ 46, 47, 15],\n", + " [172, 174, 172],\n", + " [181, 182, 182],\n", + " [168, 168, 167]],\n", + " [[113, 119, 117],\n", + " [109, 115, 113],\n", + " [117, 123, 121],\n", " ...\n", - " [ 63, 65, 25],\n", - " [ 60, 63, 22],\n", - " [ 56, 61, 18]]]), 'label': Tensor(shape=[], dtype=UInt32, value= 7)}\n" + " [155, 159, 156],\n", + " [150, 155, 155],\n", + " [135, 140, 140]],\n", + " [[121, 127, 125],\n", + " [117, 123, 121],\n", + " [121, 127, 125],\n", + " ...\n", + " [180, 184, 180],\n", + " [141, 146, 144],\n", + " [125, 130, 129]]]), 'label': Tensor(shape=[], dtype=UInt32, value= 8)}\n" ] } ], "source": [ - "cifar10_path = \"./datasets/cifar10/train\"\n", + "cifar10_path = \"./datasets/cifar-10-batches-bin/train\"\n", "\n", "# create Cifar10Dataset for reading data\n", "cifar10_dataset = ds.Cifar10Dataset(cifar10_path,shuffle=True)\n", @@ -467,9 +538,9 @@ "[4 5 6 7 8]\n", "after shuffle:\n", "[2 3 4 5 6]\n", - "[0 1 2 3 4]\n", - "[1 2 3 4 5]\n", "[3 4 5 6 7]\n", + "[1 2 3 4 5]\n", + "[0 1 2 3 4]\n", "[4 5 6 7 8]\n" ] } @@ -569,7 +640,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -585,7 +656,7 @@ "import mindspore.dataset.vision.c_transforms as C\n", "import matplotlib.pyplot as plt\n", "\n", - "cifar10_path = \"./datasets/cifar10/train\"\n", + "cifar10_path = \"./datasets/cifar-10-batches-bin/train\"\n", "\n", "# create Cifar10Dataset for reading data\n", "cifar10_dataset = ds.Cifar10Dataset(cifar10_path,num_parallel_workers=4)\n", @@ -790,9 +861,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "MindSpore-1.1.1", "language": "python", - "name": "python3" + "name": "mindspore-1.1.1" }, "language_info": { "codemirror_mode": { @@ -804,7 +875,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.5" } }, "nbformat": 4, -- Gitee From efe78130e98fee59919b7a7d593a9a5ac1db09c0 Mon Sep 17 00:00:00 2001 From: sunsuodong Date: Wed, 17 Mar 2021 17:41:52 +0800 Subject: [PATCH 03/79] compile docs --- tutorials/lite/source_en/use/build.md | 336 ++++++++++--------- tutorials/lite/source_zh_cn/use/build.md | 400 ++++++++++------------- 2 files changed, 368 insertions(+), 368 deletions(-) diff --git a/tutorials/lite/source_en/use/build.md b/tutorials/lite/source_en/use/build.md index 1bf868e2ee..d1aaf97371 100644 --- a/tutorials/lite/source_en/use/build.md +++ b/tutorials/lite/source_en/use/build.md @@ -13,15 +13,13 @@ - [Description of Converter's Directory Structure](#description-of-converters-directory-structure) - [Description of Runtime and Other tools' Directory Structure](#description-of-runtime-and-other-tools-directory-structure) - [Training Output Description](#training-output-description) - - [Description of Training Converter's Directory Structure](#description-of-training-converter-s-directory-structure) - - [Description of Training Runtime and Other tools' Directory Structure](#description-of-training-runtime-and-other-tools-directory-structure) + - [Description of Training Runtime and Related Tools' Directory Structure](#description-of-training-runtime-and-related-tools-directory-structure) - [Windows Environment Compilation](#windows-environment-compilation) - [Environment Requirements](#environment-requirements-1) - [Compilation Options](#compilation-options-1) - [Compilation Example](#compilation-example-1) - [Output Description](#output-description) - - [Description of Converter's Directory Structure](#description-of-converter-s-directory-structure-1) - - [Description of Benchmark's Directory Structure](#description-of-benchmark-s-directory-structure) + - [Description of Runtime and Related Tools' Directory Structure](#description-of-runtime-and-related-tools-directory-structure) @@ -59,13 +57,7 @@ Modules in training version: - Compilation dependencies of runtime(cpp): - [CMake](https://cmake.org/download/) >= 3.18.3 - [GCC](https://gcc.gnu.org/releases.html) >= 7.3.0 - - [Android_NDK r20b](https://dl.google.com/android/repository/android-ndk-r20b-linux-x86_64.zip) - - [Git](https://git-scm.com/downloads) >= 2.28.0 - -- Compilation dependencies of converter: - - [CMake](https://cmake.org/download/) >= 3.18.3 - - [GCC](https://gcc.gnu.org/releases.html) >= 7.3.0 - - [Android_NDK r20b](https://dl.google.com/android/repository/android-ndk-r20b-linux-x86_64.zip) + - [Android_NDK](https://dl.google.com/android/repository/android-ndk-r20b-linux-x86_64.zip) >= r20 - [Git](https://git-scm.com/downloads) >= 2.28.0 - [Autoconf](http://ftp.gnu.org/gnu/autoconf/) >= 2.69 - [Libtool](https://www.gnu.org/software/libtool/) >= 2.4.6 @@ -204,8 +196,7 @@ Then, run the following commands in the root directory of the source code to com After the compilation is complete, go to the `mindspore/output` directory of the source code to view the file generated after compilation. The file is divided into the following parts. -- `mindspore-lite-{version}-converter-{os}-{arch}.tar.gz`: Model converter. -- `mindspore-lite-{version}-inference-{os}-{arch}.tar.gz`: Contains model inference framework, benchmarking tool, performance analysis tool and library crop tool. +- `mindspore-lite-{version}-inference-{os}-{arch}.tar.gz`: Contains model inference framework runtime (cpp), and related tools. - `mindspore-lite-maven-{version}.zip`: Contains model reasoning framework AAR package. > version: Version of the output, consistent with that of the MindSpore. @@ -217,7 +208,6 @@ After the compilation is complete, go to the `mindspore/output` directory of the Execute the decompression command to obtain the compiled output: ```bash -tar -xvf mindspore-lite-{version}-converter-{os}-{arch}.tar.gz tar -xvf mindspore-lite-{version}-inference-{os}-{arch}.tar.gz unzip mindspore-lite-maven-{version}.zip ``` @@ -227,16 +217,72 @@ unzip mindspore-lite-maven-{version}.zip The conversion tool is only available under the `-I x86_64` compilation option, and the content includes the following parts: ```text -│ -├── mindspore-lite-{version}-converter-{os}-{arch} -│ └── converter # Model conversion Ttool -│ ├── converter_lite # Executable program -│ └── lib # The dynamic link library that converter depends -│ ├── libmindspore_gvar.so # A dynamic library that stores some global variables -│ └── third_party # Header files and libraries of third party libraries -│ ├── glog # Dynamic library of Glog +mindspore-lite-{version}-inference-linux-x64 +└── tools + └── converter + ├── converter # Model conversion tool + │ └── converter_lite # Executable program + ├── lib # The dynamic link library that converter depends + │ └── libmindspore_gvar.so # A dynamic library that stores some global variables + └── third_party # The dynamic link library that converter depends + └── glog + └── lib + └── libglog.so.0 # Dynamic library of Glog ``` +#### Description of Codegen's Directory Structure + +The Codegen executable program is only available under the `-I x86_64` compilation option, and only the operator library required by the inference code generated by Codegen is generated under the `-I arm64` and `-I arm32` compilation options. + +- When the compilation option is `-I x86_64`: + + ```text + mindspore-lite-{version}-inference-linux-x64 + └── tools + └── codegen # Code generation tool + ├── codegen # Executable program + └── operator_library # Operator library + ├── include # Header files of inference framework + │ ├── CMSIS # cmsis operator header file [CMSIS_5](https://github.com/ARM-software/CMSIS_5) + │ ├── nnacl # nnacl operator header file + │ └── wrapper + └── lib # Inference framework library + └── x86 + └── libops.a # MindSpore Lite Codegen generates code dependent x86 operator static library + ``` + +- When the compilation option is `-I arm64`: + + ```text + mindspore-lite-{version}-inference-android-aarch64 + └── tools + └── codegen # Code generation tool + └── operator_library # Operator library + ├── include # Header files of inference framework + │ ├── CMSIS # cmsis operator header file [CMSIS_5](https://github.com/ARM-software/CMSIS_5) + │ ├── nnacl # nnacl operator header file + │ └── wrapper + └── lib # Inference framework library + └── arm64 + └── libops.a # MindSpore Lite Codegen generates code dependent x86 operator static library + ``` + +- When the compilation option is `-I arm32`: + + ```text + mindspore-lite-{version}-inference-android-aarch32 + └── tools + └── codegen # Code generation tool + └── operator_library # Operator library + ├── include # Header files of inference framework + │ ├── CMSIS # cmsis operator header file [CMSIS_5](https://github.com/ARM-software/CMSIS_5) + │ ├── nnacl # nnacl operator header file + │ └── wrapper + └── lib # Inference framework library + └── arm32a + └── libops.a # MindSpore Lite Codegen generates code dependent x86 operator static library + ``` + #### Description of Runtime and Other tools' Directory Structure The inference framework can be obtained under `-I x86_64`, `-I arm64` and `-I arm32` compilation options, and the content includes the following parts: @@ -244,54 +290,67 @@ The inference framework can be obtained under `-I x86_64`, `-I arm64` and `-I ar - When the compilation option is `-I x86_64`: ```text - │ - ├── mindspore-lite-{version}-inference-linux-x64 - │ └── benchmark # Benchmarking Tool - │ └── cropper # Static library crop tool - │ ├── cropper # Executable file of static library crop tool - │ ├── cropper_mapping_cpu.cfg # Crop cpu library related configuration files - │ └── include # Header files of inference framework - │ └── lib # Inference framework library - │ ├── libmindspore-lite.a # Static library of infernece framework in MindSpore Lite - │ ├── libmindspore-lite.so # Dynamic library of infernece framework in MindSpore Lite + mindspore-lite-{version}-inference-linux-x64 + ├── inference + │ ├── include # Header files of inference framework + │ ├── lib # Inference framework library + │ │ ├── libmindspore-lite.a # Static library of infernece framework in MindSpore Lite + │ │ └── libmindspore-lite.so # Dynamic library of infernece framework in MindSpore Lite │ └── minddata # Image processing dynamic library - │ └── include # Header files - │ └── lite_cv # The Header files of image processing dynamic library - │ ├── image_process.h # The Header files of image processing function - │ ├── lite_mat.h # The Header files of image data class structure - │ └── lib # Image processing dynamic library - │ ├── libminddata-lite.so # The files of image processing dynamic library + │ ├── include + │ └── lib + │ └── libminddata-lite.so # The files of image processing dynamic library + └── tools + ├── benchmark # Benchmarking tool + │ └── benchmark # Executable program + ├── codegen # Code generation tool + │ ├── codegen # Executable program + │ └── operator_library # Operator library + ├── converter # Model conversion tool + └── cropper # Static library crop tool + ├── cropper # Executable file of static library crop tool + └── cropper_mapping_cpu.cfg # Crop cpu library related configuration files ``` - When the compilation option is `-I arm64` or `-I arm32`: ```text - │ - ├── mindspore-lite-{version}-inference-android-{arch} - │ └── benchmark # Benchmarking Tool - │ └── include # Header files of inference framework - │ └── lib # Inference framework library - │ ├── libmindspore-lite.a # Static library of infernece framework in MindSpore Lite - │ ├── libmindspore-lite.so # Dynamic library of infernece framework in MindSpore Lite - │ └── minddata # Image processing dynamic library - │ └── include # Header files - │ └── lite_cv # The Header files of image processing dynamic library - │ ├── image_process.h # The Header files of image processing function - │ ├── lite_mat.h # The Header files of image data class structure - │ └── lib # Image processing dynamic library - │ ├── libminddata-lite.so # The files of image processing dynamic library + mindspore-lite-{version}-inference-android-{arch} + ├── inference + │ ├── include # Header files of inference framework + │ ├── lib # Inference framework library + │ │ ├── libmindspore-lite.a # Static library of infernece framework in MindSpore Lite + │ │ └── libmindspore-lite.so # Dynamic library of infernece framework in MindSpore Lite + │ ├── minddata # Image processing dynamic library + │ │ ├── include + │ │ └── lib + │ │ └── libminddata-lite.so # The files of image processing dynamic library + │ └── third_party # NPU library + │ └── hiai_ddk + └── tools + ├── benchmark # Benchmarking tool + │ └── benchmark + └── codegen # Code generation tool + └── operator_library # Operator library ``` - When the compilation option is `-A java`: - ```text - │ - ├── mindspore-lite-maven-{version} - │ └── mindspore - │ └── mindspore-lite - │ └── {version} - │ ├── mindspore-lite-{version}.aar # MindSpore Lite runtime aar - ``` + ```text + mindspore-lite-maven-{version} + └── mindspore + └── mindspore-lite + └── {version} + └── mindspore-lite-{version}.aar # MindSpore Lite runtime aar + ``` + + ```text + mindspore-lite-{version}-inference-linux-x64-jar + └── jar + ├── libmindspore-lite-jni.so # Dynamic library of MindSpore Lite inference framework + ├── libmindspore-lite.so # MindSpore Lite JNI dynamic library + └── mindspore-lite-java.jar # MindSpore Lite inference framework jar package + ``` > 1. Compile ARM64 to get the inference framework output of cpu/gpu/npu by default, if you add `-e gpu`, you will get the inference framework output of cpu/gpu, ARM32 only supports CPU. > @@ -300,20 +359,19 @@ The inference framework can be obtained under `-I x86_64`, `-I arm64` and `-I ar Configure converter: ```bash -export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-converter-{os}-{arch}/lib:./output/mindspore-lite-{version}-converter-{os}-{arch}/third_party/glog/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-inference-{os}-{arch}/tools/converter/lib:./output/mindspore-lite-{version}-inference-{os}-{arch}/tools/converter/third_party/glog/lib:${LD_LIBRARY_PATH} ``` Configure benchmark: ```bash -export LD_LIBRARY_PATH= ./output/mindspore-lite-{version}-inference-{os}-{arch}/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-inference-{os}-{arch}/inference/lib:${LD_LIBRARY_PATH} ``` ### Training Output Description If the `-T on` is added to the MindSpore Lite, go to the `mindspore/output` directory of the source code to view the file generated after compilation. The file is divided into the following parts. -- `mindspore-lite-{version}-converter-{os}-{arch}.tar.gz`: Model converter, only support MINDIR format model file. - `mindspore-lite-{version}-train-{os}-{arch}.tar.gz`: Contains model training framework, performance analysis tool. > version: Version of the output, consistent with that of the MindSpore. @@ -325,70 +383,59 @@ If the `-T on` is added to the MindSpore Lite, go to the `mindspore/output` dire Execute the decompression command to obtain the compiled output: ```bash -tar -xvf mindspore-lite-{version}-converter-{os}-{arch}.tar.gz tar -xvf mindspore-lite-{version}-train-{os}-{arch}.tar.gz ``` -#### Description of Training Converter's Directory Structure - -The training model conversion tool is only available under the `-I x86_64` compilation option, and the content includes the following parts: - -```text -│ -├── mindspore-lite-{version}-converter-linux-x64 -│ └── converter # Model conversion Ttool -│ ├── converter_lite # Executable program -│ └── lib # The dynamic link library that converter depends -│ ├── libmindspore_gvar.so # A dynamic library that stores some global variables -│ └── third_party # Header files and libraries of third party libraries -│ ├── glog # Dynamic library of Glog -``` - -#### Description of Training Runtime and Other tools' Directory Structure +#### Description of Training Runtime and Related Tools' Directory Structure The MindSpore Lite training framework can be obtained under `-I x86_64`, `-I arm64` and `-I arm32` compilation options, and the content includes the following parts: - When the compilation option is `-I x86_64`: ```text - │ - ├── mindspore-lite-{version}-train-linux-x64 - │ └── cropper # Static library crop tool - │ ├── cropper # Executable file of static library crop tool - │ ├── cropper_mapping_cpu.cfg # Crop cpu library related configuration files - │ └── include # Header files of training framework - │ └── lib # Inference framework library - │ ├── libmindspore-lite.a # Static library of training framework in MindSpore Lite - │ ├── libmindspore-lite.so # Dynamic library of training framework in MindSpore Lite - │ └── minddata # Image processing dynamic library - │ └── include # Header files - │ └── lite_cv # The Header files of image processing dynamic library - │ ├── image_process.h # The Header files of image processing function - │ ├── lite_mat.h # The Header files of image data class structure - │ └── lib # Image processing dynamic library - │ ├── libminddata-lite.so # The files of image processing dynamic library - │ └── benchmark_train - │ ├── benchmark_train # training model benchmark tool + mindspore-lite-{version}-train-linux-x64 + ├── tools + │ ├── benchmark # Benchmarking tool + │ ├── benchmark_train # Training model benchmark tool + │ ├── codegen # Code generation tool + │ │ ├── codegen # Executable program + │ │ └── operator_library # Operator library + │ ├── converter # Model conversion tool + │ └── cropper # Static library crop tool + │ ├── cropper # Executable file of static library crop tool + │ └── cropper_mapping_cpu.cfg # Crop cpu library related configuration files + └── train + ├── include # Header files of training framework + ├── lib # Inference framework library + │ ├── libmindspore-lite.a # Static library of training framework in MindSpore Lite + │ └── libmindspore-lite.so # Dynamic library of training framework in MindSpore Lite + └── minddata # Image processing dynamic library + ├── include + ├── lib + │ └── libminddata-lite.so # The files of image processing dynamic library + └── third_party ``` - When the compilation option is `-I arm64` or `-I arm32`: ```text - │ - ├── mindspore-lite-{version}-train-android-{arch} - │ └── include # Header files of training framework - │ └── lib # Training framework library - │ ├── libmindspore-lite.a # Static library of training framework in MindSpore Lite - │ ├── libmindspore-lite.so # Dynamic library of training framework in MindSpore Lite - │ └── minddata # Image processing dynamic library - │ └── include # Header files - │ └── lite_cv # The Header files of image processing dynamic library - │ ├── image_process.h # The Header files of image processing function - │ ├── lite_mat.h # The Header files of image data class structure - │ └── lib # Image processing dynamic library - │ ├── libminddata-lite.so # The files of image processing dynamic library - │ └── benchmark_train - │ ├── benchmark_train # training model benchmark tool + mindspore-lite-{version}-train-android-{arch} + ├── tools + │ ├── benchmark # Benchmarking tool + │ ├── benchmark_train # Training model benchmark tool + │ └── codegen # Code generation tool + │ └── operator_library # Operator library + └── train + ├── include # Header files of training framework + ├── lib # Training framework library + │ ├── libmindspore-lite.a # Static library of training framework in MindSpore Lite + │ └── libmindspore-lite.so # Dynamic library of training framework in MindSpore Lite + ├── minddata # Image processing dynamic library + │ ├── include + │ ├── lib + │ │ └── libminddata-lite.so # The files of image processing dynamic library + │ └── third_party + └── third_party ``` > Before running the tools in the converter and the benchmark_train directory, you need to configure environment variables, and configure the path where the dynamic libraries of MindSpore Lite are located to the path where the system searches for dynamic libraries. @@ -396,13 +443,13 @@ The MindSpore Lite training framework can be obtained under `-I x86_64`, `-I arm Configure converter: ```bash -export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-converter-{os}-{arch}/lib:./output/mindspore-lite-{version}-converter-{os}-{arch}/third_party/glog/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-train-{os}-{arch}/tools/converter/lib:./output/mindspore-lite-{version}-train-{os}-{arch}/tools/converter/third_party/glog/lib:${LD_LIBRARY_PATH} ``` Configure benchmark_train: ```bash -export LD_LIBRARY_PATH= ./output/mindspore-lite-{version}-train-{os}-{arch}/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-train-{os}-{arch}/train/lib:${LD_LIBRARY_PATH} ``` ## Windows Environment Compilation @@ -452,52 +499,47 @@ call build.bat lite 8 After the compilation is complete, go to the `mindspore/output` directory of the source code to view the file generated after compilation. The file is divided into the following parts. -- `mindspore-lite-{version}-converter-win-x64.zip`: Contains model conversion tool. -- `mindspore-lite-{version}-inference-win-x64.zip`: Contains model inference framework and benchmarking tool. +- `mindspore-lite-{version}-inference-win-x64.zip`: Contains model inference framework and related tool. > version: Version of the output, consistent with that of the MindSpore. Execute the decompression command to obtain the compiled output: ```bat -unzip mindspore-lite-{version}-converter-win-x64.zip unzip mindspore-lite-{version}-inference-win-x64.zip ``` -#### Description of Converter's Directory Structure - -The content includes the following parts: - -```text -│ -├── mindspore-lite-{version}-converter-win-x64 -│ └── converter # Model conversion Ttool -│ ├── converter_lite # Executable program -│ ├── libglog.dll # Dynamic library of Glog -│ ├── libmindspore_gvar.dll # A dynamic library that stores some global variables -│ ├── libgcc_s_seh-1.dll # Dynamic library of MinGW -│ ├── libssp-0.dll # Dynamic library of MinGW -│ ├── libstdc++-6.dll # Dynamic library of MinGW -│ ├── libwinpthread-1.dll # Dynamic library of MinGW -``` - -#### Description of Benchmark's Directory Structure +#### Description of Runtime and Related Tools' Directory Structure The content includes the following parts: ```text -│ -├── mindspore-lite-{version}-inference-win-x64 -│ └── benchmark # Benchmarking Tool -│ ├── benchmark.exe # Executable program -│ ├── libmindspore-lite.a # Static library of infernece framework in MindSpore Lite -│ ├── libmindspore-lite.dll # Dynamic library of infernece framework in MindSpore Lite +mindspore-lite-{version}-inference-win-x64 +├── inference +│ ├── include # Header files of inference framework +│ └── lib +│ ├── libgcc_s_seh-1.dll # Dynamic library of MinGW +│ ├── libmindspore-lite.a # Static library of infernece framework in MindSpore Lite +│ ├── libmindspore-lite.dll # Dynamic library of infernece framework in MindSpore Lite │ ├── libmindspore-lite.dll.a # Link file of dynamic library of infernece framework in MindSpore Lite -│ ├── libgcc_s_seh-1.dll # Dynamic library of MinGW -│ ├── libssp-0.dll # Dynamic library of MinGW -│ ├── libstdc++-6.dll # Dynamic library of MinGW -│ ├── libwinpthread-1.dll # Dynamic library of MinGW -│ └── include # Header files of inference framework +│ ├── libssp-0.dll # Dynamic library of MinGW +│ ├── libstdc++-6.dll # Dynamic library of MinGW +│ └── libwinpthread-1.dll # Dynamic library of MinGW +└── tools + ├── benchmark # Benchmarking tool + │ └── benchmark.exe # Executable program + ├── codegen # Code generation tool + │ └── codegen.exe # Executable program + └── converter # Model conversion tool + ├── converter + │ └── converter_lite.exe # Executable program + └── lib + ├── libgcc_s_seh-1.dll # Dynamic library of MinGW + ├── libglog.dll # Dynamic library of Glog + ├── libmindspore_gvar.dll # A dynamic library that stores some global variables + ├── libssp-0.dll # Dynamic library of MinGW + ├── libstdc++-6.dll # Dynamic library of MinGW + └── libwinpthread-1.dll # Dynamic library of MinGW ``` > Currently, MindSpore Lite is not supported on Windows. diff --git a/tutorials/lite/source_zh_cn/use/build.md b/tutorials/lite/source_zh_cn/use/build.md index 211c9d58fe..9ea67d79c9 100644 --- a/tutorials/lite/source_zh_cn/use/build.md +++ b/tutorials/lite/source_zh_cn/use/build.md @@ -14,15 +14,13 @@ - [代码生成工具Codegen目录结构说明](#代码生成工具Codegen目录结构说明) - [Runtime及其他工具目录结构说明](#推理Runtime及其他工具目录结构说明) - [端侧训练框架编译输出](#端侧训练框架编译输出) - - [训练模型转换工具converter目录结构说明](#训练模型转换工具converter目录结构说明) - - [训练Runtime及其他工具目录结构说明](#训练Runtime及其他工具目录结构说明) + - [训练Runtime及配套工具目录结构说明](#训练Runtime及配套工具目录结构说明) - [Windows环境编译](#windows环境编译) - [环境要求](#环境要求-1) - [编译选项](#编译选项-1) - [编译示例](#编译示例-1) - [端侧推理框架编译输出](#端侧推理框架编译输出) - - [模型转换工具converter目录结构说明](#模型转换工具converter目录结构说明-1) - - [基准测试工具benchmark目录结构说明](#基准测试工具benchmark目录结构说明-1) + - [Runtime及配套工具目录结构说明](#Runtime及配套工具目录结构说明-1) @@ -62,11 +60,6 @@ - [GCC](https://gcc.gnu.org/releases.html) >= 7.3.0 - [Android_NDK](https://dl.google.com/android/repository/android-ndk-r20b-linux-x86_64.zip) >= r20 - [Git](https://git-scm.com/downloads) >= 2.28.0 -- converter编译依赖 - - [CMake](https://cmake.org/download/) >= 3.18.3 - - [GCC](https://gcc.gnu.org/releases.html) >= 7.3.0 - - [Android_NDK](https://dl.google.com/android/repository/android-ndk-r20b-linux-x86_64.zip) >= r20 - - [Git](https://git-scm.com/downloads) >= 2.28.0 - [Autoconf](http://ftp.gnu.org/gnu/autoconf/) >= 2.69 - [Libtool](https://www.gnu.org/software/libtool/) >= 2.4.6 - [LibreSSL](http://www.libressl.org/) >= 3.1.3 @@ -82,10 +75,6 @@ - [Android SDK](https://developer.android.com/studio?hl=zh-cn#cmdline-tools) - [Gradle](https://gradle.org/releases/) >= 6.6.1 - [OpenJDK](https://openjdk.java.net/install/) >= 1.8 -- Codegen编译依赖 - - [CMake](https://cmake.org/download/) >= 3.18.3 - - [GCC](https://gcc.gnu.org/releases.html) >= 7.3.0 - - [Git](https://git-scm.com/downloads) >= 2.28.0 > - 当安装完依赖项`Android_NDK`后，需配置环境变量：`export ANDROID_NDK=${NDK_PATH}/android-ndk-r20b`。 > - 编译脚本中会执行`git clone`获取第三方依赖库的代码，请提前确保git的网络设置正确可用。 @@ -207,14 +196,10 @@ git clone https://gitee.com/mindspore/mindspore.git 执行编译指令后，会在`mindspore/output/`目录中生成如下文件： -- `mindspore-lite-{version}-converter-{os}-{arch}.tar.gz`：模型转换工具。 - -- `mindspore-lite-{version}-inference-{os}-{arch}.tar.gz`：包含模型推理框架runtime、基准测试工具benchmark、库裁剪工具cropper。 +- `mindspore-lite-{version}-inference-{os}-{arch}.tar.gz`：包含模型推理框架runtime(cpp)和配套工具。 - `mindspore-lite-maven-{version}.zip`：包含模型推理框架runtime(java)的AAR。 -- `mindspore-lite-{version}-codegen-{os}-{arch}.tar.gz`：模型编译，代码生成工具。 - > version: 输出件版本号，与所编译的分支代码对应的版本一致。 > > os: 输出件应部署的操作系统。 @@ -224,10 +209,8 @@ git clone https://gitee.com/mindspore/mindspore.git 执行解压缩命令，获取编译后的输出件： ```bash -tar -xvf mindspore-lite-{version}-converter-{os}-{arch}.tar.gz tar -xvf mindspore-lite-{version}-inference-{os}-{arch}.tar.gz unzip mindspore-lite-maven-{version}.zip -tar -xvf mindspore-lite-{version}-codegen-{os}-{arch}.tar.gz ``` #### 模型转换工具converter目录结构说明 @@ -235,78 +218,71 @@ tar -xvf mindspore-lite-{version}-codegen-{os}-{arch}.tar.gz 仅在`-I x86_64`编译选项下获得（推理和训练的目录结构相同）内容如下： ```text -│ -├── mindspore-lite-{version}-converter-{os}-{arch} -│ └── converter # 模型转换工具 -│ ├── converter_lite # 可执行程序 -│ └── lib # 转换工具依赖的动态库 -│ ├── libmindspore_gvar.so # 存储某些全局变量的动态库 -│ └── third_party # 第三方库头文件和库 -│ ├── glog # Glog的动态库 +mindspore-lite-{version}-inference-linux-x64 +└── tools + └── converter + ├── converter # 模型转换工具 + │ └── converter_lite # 可执行程序 + ├── lib # 转换工具依赖的动态库 + │ └── libmindspore_gvar.so # 存储某些全局变量的动态库 + └── third_party # 转换工具依赖的动态库 + └── glog + └── lib + └── libglog.so.0 # Glog的动态库 ``` #### 代码生成工具Codegen目录结构说明 -仅在`-I x86_64`编译选项下获得Codegen，在`-I arm64`和`-I arm32`编译选项下只生成Codegen生成的推理代码所需要的算子库。 +仅在`-I x86_64`编译选项下获得Codegen可执行程序，在`-I arm64`和`-I arm32`编译选项下只生成Codegen生成的推理代码所需要的算子库。 - `-I x86_64`编译选项下获得Codegen，内容如下： -```text -│ -├── mindspore-lite-{version}-codegen-{os}-{arch} -│ └── codegen # 代码成功工具 -│ ├── codegen # 可执行程序 -│ └── include # 推理框架头文件 -│ └── CMSIS # cmsis 算子头文件[CMSIS_5](https://github.com/ARM-software/CMSIS_5) -│ └── Core -│ └── DSP -│ └── NN -| └── nnacl # nnacl 算子头文件 -│ └── base -│ └── fp32 -│ └── int8 -│ └── lib # 推理框架库 -│ └── x86 -│ ├── libops.a # MindSpore Lite Codegen生成代码依赖的x86算子静态库 -``` + ```text + mindspore-lite-{version}-inference-linux-x64 + └── tools + └── codegen # 代码生成工具 + ├── codegen # 可执行程序 + └── operator_library # 算子库 + ├── include # 推理框架头文件 + │ ├── CMSIS # cmsis 算子头文件[CMSIS_5](https://github.com/ARM-software/CMSIS_5) + │ ├── nnacl # nnacl 算子头文件 + │ └── wrapper + └── lib # 推理框架库 + └── x86 + └── libops.a # MindSpore Lite Codegen生成代码依赖的x86算子静态库 + ``` - `-I arm64`编译选项下获得Codegen，内容如下： - ```text - │ - ├── mindspore-lite-codegen-android-{arch} - │ └── include # 推理框架头文件 - │ └── CMSIS # cmsis 算子头文件[CMSIS_5](https://github.com/ARM-software/CMSIS_5) - │ └── Core - │ └── DSP - │ └── NN - | └── nnacl # nnacl 算子头文件 - │ └── base - │ └── fp32 - │ └── int8 - │ └── lib # 推理框架库 - │ └── arm64 - │ ├── libops.a # MindSpore Lite Codegen生成代码依赖的arm64算子静态库 -``` + ```text + mindspore-lite-{version}-inference-android-aarch64 + └── tools + └── codegen # 代码生成工具 + └── operator_library # 算子库 + ├── include # 推理框架头文件 + │ ├── CMSIS # cmsis 算子头文件[CMSIS_5](https://github.com/ARM-software/CMSIS_5) + │ ├── nnacl # nnacl 算子头文件 + │ └── wrapper + └── lib # 推理框架库 + └── arm64 + └── libops.a # MindSpore Lite Codegen生成代码依赖的arm64算子静态库 + ``` - `-I arm32`编译选项下获得Codegen，内容如下： - ```text - | - ├── mindspore-lite-codegen-android-{arch} - │ └── include # 推理框架头文件 - │ └── CMSIS # cmsis 算子头文件[CMSIS_5](https://github.com/ARM-software/CMSIS_5) - │ └── Core - │ └── DSP - │ └── NN - | └── nnacl # nnacl 算子头文件 - │ └── base - │ └── fp32 - │ └── int8 - │ └── lib # 推理框架库 - │ └── arm32 - │ ├── libops.a # MindSpore Lite Codegen生成代码依赖的arm32算子静态库 -``` + ```text + mindspore-lite-{version}-inference-android-aarch32 + └── tools + └── codegen # 代码生成工具 + └── operator_library # 算子库 + ├── include # 推理框架头文件 + │ ├── CMSIS # cmsis 算子头文件[CMSIS_5](https://github.com/ARM-software/CMSIS_5) + │ ├── nnacl # nnacl 算子头文件 + │ └── wrapper + └── lib # 推理框架库 + └── arm32a + └── libops.a # MindSpore Lite Codegen生成代码依赖的arm32算子静态库 + ``` #### Runtime及其他工具目录结构说明 @@ -315,64 +291,67 @@ tar -xvf mindspore-lite-{version}-codegen-{os}-{arch}.tar.gz - 当编译选项为`-I x86_64`时： ```text - │ - ├── mindspore-lite-{version}-inference-linux-x64 - │ └── benchmark # 基准测试工具 - │ └── cropper # 库裁剪工具 - │ ├── cropper # 库裁剪工具可执行文件 - │ ├── cropper_mapping_cpu.cfg # 裁剪cpu库所需的配置文件 - │ └── include # 推理框架头文件 - │ └── lib # 推理框架库 - │ ├── libmindspore-lite.a # MindSpore Lite推理框架的静态库 - │ ├── libmindspore-lite.so # MindSpore Lite推理框架的动态库 - │ └── minddata # 图像处理动态库 - │ └── include # 头文件 - │ └── lite_cv # 图像处理库头文件 - │ ├── image_process.h # 图像处理函数头文件 - │ ├── lite_mat.h # 图像数据类结构头文件 - │ └── lib # 图像处理动态库 - │ ├── libminddata-lite.so # 图像处理动态库文件 + mindspore-lite-{version}-inference-linux-x64 + ├── inference + │ ├── include # 推理框架头文件 + │ ├── lib # 推理框架库 + │ │ ├── libmindspore-lite.a # MindSpore Lite推理框架的静态库 + │ │ └── libmindspore-lite.so # MindSpore Lite推理框架的动态库 + │ └── minddata # 图像处理库 + │ ├── include + │ └── lib + │ └── libminddata-lite.so # 图像处理动态库文件 + └── tools + ├── benchmark # 基准测试工具 + │ └── benchmark # 可执行程序 + ├── codegen # 代码生成工具 + │ ├── codegen # 可执行程序 + │ └── operator_library # 算子库 + ├── converter # 模型转换工具 + └── cropper # 库裁剪工具 + ├── cropper # 库裁剪工具可执行文件 + └── cropper_mapping_cpu.cfg # 裁剪cpu库所需的配置文件 ``` - 当编译选项为`-I arm64`或`-I arm32`时： ```text - │ - ├── mindspore-lite-{version}-inference-android-{arch} - │ └── benchmark # 基准测试工具 - │ └── include # 推理框架头文件 - │ └── lib # 推理框架库 - │ ├── libmindspore-lite.a # MindSpore Lite推理框架的静态库 - │ ├── libmindspore-lite.so # MindSpore Lite推理框架的动态库 - │ └── minddata # 图像处理动态库 - │ └── include # 头文件 - │ └── lite_cv # 图像处理库头文件 - │ ├── image_process.h # 图像处理函数头文件 - │ ├── lite_mat.h # 图像数据类结构头文件 - │ └── lib # 图像处理动态库 - │ ├── libminddata-lite.so # 图像处理动态库文件 + mindspore-lite-{version}-inference-android-{arch} + ├── inference + │ ├── include # 推理框架头文件 + │ ├── lib # 推理框架库 + │ │ ├── libmindspore-lite.a # MindSpore Lite推理框架的静态库 + │ │ └── libmindspore-lite.so # MindSpore Lite推理框架的动态库 + │ ├── minddata # 图像处理库 + │ │ ├── include + │ │ └── lib + │ │ └── libminddata-lite.so # 图像处理动态库文件 + │ └── third_party # NPU库 + │ └── hiai_ddk + └── tools + ├── benchmark # 基准测试工具 + │ └── benchmark + └── codegen # 代码生成工具 + └── operator_library # 算子库 ``` - 当编译选项为`-A java`时： - ```text - │ - ├── mindspore-lite-maven-{version} - │ └── mindspore - │ └── mindspore-lite - │ └── {version} - │ ├── mindspore-lite-{version}.aar # MindSpore Lite推理框架aar包 - ``` - - ```text - │ - ├── mindspore-lite-{version}-inference-linux-x64 - │ └── lib # 推理框架库 - │ └── jar - │ ├── libmindspore-lite.so # MindSpore Lite推理框架的动态库 - │ ├── libmindspore-lite-jni.so # MindSpore Lite JNI的动态库 - │ ├── libmindspore-lite-java.jar # MindSpore Lite推理框架jar包 - ``` + ```text + mindspore-lite-maven-{version} + └── mindspore + └── mindspore-lite + └── {version} + └── mindspore-lite-{version}.aar # MindSpore Lite推理框架aar包 + ``` + + ```text + mindspore-lite-{version}-inference-linux-x64-jar + └── jar + ├── libmindspore-lite-jni.so # MindSpore Lite推理框架的动态库 + ├── libmindspore-lite.so # MindSpore Lite JNI的动态库 + └── mindspore-lite-java.jar # MindSpore Lite推理框架jar包 + ``` > 1. 编译ARM64默认可获得cpu/gpu/npu的推理框架输出件，若添加`-e gpu`则获得cpu/gpu的推理框架输出件，ARM32仅支持CPU。 > @@ -381,21 +360,19 @@ tar -xvf mindspore-lite-{version}-codegen-{os}-{arch}.tar.gz 配置converter： ```bash -export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-converter-{os}-{arch}/lib:./output/mindspore-lite-{version}-converter-{os}-{arch}/third_party/glog/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-inference-{os}-{arch}/tools/converter/lib:./output/mindspore-lite-{version}-inference-{os}-{arch}/tools/converter/third_party/glog/lib:${LD_LIBRARY_PATH} ``` 配置benchmark： ```bash -export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-inference-{os}-{arch}/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-inference-{os}-{arch}/inference/lib:${LD_LIBRARY_PATH} ``` ### 端侧训练框架编译输出 如果添加了`-T on`编译选项，会生成端侧训练转换工具和对应Runtime工具，如下： -`mindspore-lite-{version}-converter-{os}-{arch}.tar.gz`：模型转换工具，仅支持MindIR模型文件。 - `mindspore-lite-{version}-train-{os}-{arch}.tar.gz`：模型训练框架runtime。 > version: 输出件版本号，与所编译的分支代码对应的版本一致。 @@ -407,73 +384,59 @@ export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-inference-{os}-{arch}/l 执行解压缩命令，获取编译后的输出件： ```bash -tar -xvf mindspore-lite-{version}-converter-{os}-{arch}.tar.gz tar -xvf mindspore-lite-{version}-train-{os}-{arch}.tar.gz ``` -#### 训练模型转换工具converter目录结构说明 - -仅在`-I x86_64`编译选项下获得内容如下： - -```text -│ -├── mindspore-lite-{version}-converter-linux-x64 -│ └── converter # 模型转换工具 -│ ├── converter_lite # 可执行程序 -│ └── lib # 转换工具依赖的动态库 -│ ├── libmindspore_gvar.so # 存储某些全局变量的动态库 -│ └── minddata # 图像处理动态库 -│ ├── include # 头文件 -│ └── third_party # 第三方库头文件和库 -│ ├── glog # Glog的动态库 -``` - -#### 训练Runtime及其他工具目录结构说明 +#### 训练Runtime及配套工具目录结构说明 训练框架可在`-I x86_64`、`-I arm64`、`-I arm32`编译选项下获得对应不同硬件平台的版本，内容如下： - 当编译选项为`-I x86_64`时： ```text - │ - ├── mindspore-lite-{version}-train-linux-x64 - │ └── benchmark # 基准测试工具 - │ └── cropper # 库裁剪工具 - │ ├── cropper # 库裁剪工具可执行文件 - │ ├── cropper_mapping_cpu.cfg # 裁剪cpu库所需的配置文件 - │ └── include # 训练框架头文件 - │ └── lib # 训练框架库 - │ ├── libmindspore-lite.a # MindSpore Lite训练框架的静态库 - │ ├── libmindspore-lite.so # MindSpore Lite训练框架的动态库 - │ └── minddata # 图像处理动态库 - │ └── include # 头文件 - │ └── lite_cv # 图像处理库头文件 - │ ├── image_process.h # 图像处理函数头文件 - │ ├── lite_mat.h # 图像数据类结构头文件 - │ └── lib # 图像处理动态库 - │ ├── libminddata-lite.so # 图像处理动态库文件 - │ └── benchmark_train - │ ├── benchmark_train # 训练模型性能与精度调测工具 + mindspore-lite-{version}-train-linux-x64 + ├── tools + │   ├── benchmark # 基准测试工具 + │   ├── benchmark_train # 训练模型性能与精度调测工具 + │   ├── codegen # 代码生成工具 + │   │   ├── codegen # 可执行程序 + │   │   └── operator_library # 算子库 + │   ├── converter # 模型转换工具 + │   └── cropper # 库裁剪工具 + │   ├── cropper # 库裁剪工具可执行文件 + │   └── cropper_mapping_cpu.cfg # 裁剪cpu库所需的配置文件 + └── train + ├── include # 训练框架头文件 + ├── lib # 训练框架库 + │   ├── libmindspore-lite.a # MindSpore Lite训练框架的静态库 + │   └── libmindspore-lite.so # MindSpore Lite训练框架的动态库 + └── minddata # 图像处理库 + ├── include + ├── lib + │   └── libminddata-lite.so # 图像处理动态库文件 + └── third_party ``` - 当编译选项为`-I arm64`或`-I arm32`时： ```text - │ - ├── mindspore-lite-{version}-train-android-{arch} - │ └── include # 训练框架头文件 - │ └── lib # 训练框架库 - │ ├── libmindspore-lite.a # MindSpore Lite训练框架的静态库 - │ ├── libmindspore-lite.so # MindSpore Lite训练框架的动态库 - │ └── minddata # 图像处理动态库 - │ └── include # 头文件 - │ └── lite_cv # 图像处理库头文件 - │ ├── image_process.h # 图像处理函数头文件 - │ ├── lite_mat.h # 图像数据类结构头文件 - │ └── lib # 图像处理动态库 - │ ├── libminddata-lite.so # 图像处理动态库文件 - │ └── benchmark_train - │ ├── benchmark_train # 训练模型性能与精度调测工具 + mindspore-lite-{version}-train-android-{arch} + ├── tools + │   ├── benchmark # 基准测试工具 + │   ├── benchmark_train # 训练模型性能与精度调测工具 + │   └── codegen # 代码生成工具 + │   └── operator_library # 算子库 + └── train + ├── include # 训练框架头文件 + ├── lib # 训练框架库 + │   ├── libmindspore-lite.a # MindSpore Lite训练框架的静态库 + │   └── libmindspore-lite.so # MindSpore Lite训练框架的动态库 + ├── minddata # 图像处理库 + │   ├── include + │   ├── lib + │   │   └── libminddata-lite.so # 图像处理动态库文件 + │   └── third_party + └── third_party ``` > 运行converter、benchmark_train目录下的工具前，都需配置环境变量，将MindSpore Lite的动态库所在的路径配置到系统搜索动态库的路径中。 @@ -481,13 +444,13 @@ tar -xvf mindspore-lite-{version}-train-{os}-{arch}.tar.gz 配置converter： ```bash -export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-converter-{os}-{arch}/lib:./output/mindspore-lite-{version}-converter-{os}-{arch}/third_party/glog/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-train-{os}-{arch}/tools/converter/lib:./output/mindspore-lite-{version}-train-{os}-{arch}/tools/converter/third_party/glog/lib:${LD_LIBRARY_PATH} ``` 配置benchmark_train： ```bash -export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-train-{os}-{arch}/lib:${LD_LIBRARY_PATH} +export LD_LIBRARY_PATH=./output/mindspore-lite-{version}-train-{os}-{arch}/train/lib:${LD_LIBRARY_PATH} ``` ## Windows环境编译 @@ -537,52 +500,47 @@ call build.bat lite 8 编译完成后，进入`mindspore/output/`目录，可查看编译后生成的文件。文件分为以下几种： -- `mindspore-lite-{version}-converter-win-x64.zip`：包含模型转换工具converter。 -- `mindspore-lite-{version}-inference-win-x64.zip`：包含模型推理框架runtime、基准测试工具benchmark。 +- `mindspore-lite-{version}-inference-win-x64.zip`：包含模型推理框架runtime和配套工具。 > version：输出件版本号，与所编译的分支代码对应的版本一致。 执行解压缩命令，获取编译后的输出件： ```bat -unzip mindspore-lite-{version}-converter-win-x64.zip unzip mindspore-lite-{version}-inference-win-x64.zip ``` -#### 模型转换工具converter目录结构说明 - -转换工具的内容包括以下几部分： - -```text -│ -├── mindspore-lite-{version}-converter-win-x64 -│ └── converter # 模型转换工具 -│ ├── converter_lite.exe # 可执行程序 -│ ├── libglog.dll # Glog的动态库 -│ ├── libmindspore_gvar.dll # 存储某些全局变量的动态库 -│ ├── libgcc_s_seh-1.dll # MinGW动态库 -│ ├── libssp-0.dll # MinGW动态库 -│ ├── libstdc++-6.dll # MinGW动态库 -│ ├── libwinpthread-1.dll # MinGW动态库 -``` - -#### 基准测试工具benchmark目录结构说明 +#### Runtime及配套工具目录结构说明 -基准测试工具的内容包括以下几部分： +Runtime及配套工具包括以下几部分： ```text -│ -├── mindspore-lite-{version}-inference-win-x64 -│ └── benchmark # 基准测试工具 -│ ├── benchmark.exe # 可执行程序 -│ ├── libmindspore-lite.a # MindSpore Lite推理框架的静态库 -│ ├── libmindspore-lite.dll # MindSpore Lite推理框架的动态库 -│ ├── libmindspore-lite.dll.a # MindSpore Lite推理框架的动态库的链接文件 -│ ├── libgcc_s_seh-1.dll # MinGW动态库 -│ ├── libssp-0.dll # MinGW动态库 -│ ├── libstdc++-6.dll # MinGW动态库 -│ ├── libwinpthread-1.dll # MinGW动态库 -│ └── include # 推理框架头文件 +mindspore-lite-{version}-inference-win-x64 +├── inference +│   ├── include # 推理框架头文件 +│   └── lib +│   ├── libgcc_s_seh-1.dll # MinGW动态库 +│   ├── libmindspore-lite.a # MindSpore Lite推理框架的静态库 +│   ├── libmindspore-lite.dll # MindSpore Lite推理框架的动态库 +│   ├── libmindspore-lite.dll.a # MindSpore Lite推理框架的动态库的链接文件 +│   ├── libssp-0.dll # MinGW动态库 +│   ├── libstdc++-6.dll # MinGW动态库 +│   └── libwinpthread-1.dll # MinGW动态库 +└── tools + ├── benchmark # 基准测试工具 + │   └── benchmark.exe # 可执行程序 + ├── codegen # 代码生成工具 + │   └── codegen.exe # 可执行程序 + └── converter # 模型转换工具 + ├── converter + │   └── converter_lite.exe # 可执行程序 + └── lib + ├── libgcc_s_seh-1.dll # MinGW动态库 + ├── libglog.dll # Glog的动态库 + ├── libmindspore_gvar.dll # 存储某些全局变量的动态库 + ├── libssp-0.dll # MinGW动态库 + ├── libstdc++-6.dll # MinGW动态库 + └── libwinpthread-1.dll # MinGW动态库 ``` > 暂不支持在Windows进行端侧训练。 -- Gitee From 53178cb020f4a34b7d17c7567c57bfb650d2014d Mon Sep 17 00:00:00 2001 From: dingpeifei Date: Thu, 18 Mar 2021 17:14:18 +0800 Subject: [PATCH 04/79] IR operators of GPU and CPU are unified as batchnorm --- docs/api_python/source_en/mindspore/operations.rst | 2 -- docs/api_python/source_zh_cn/mindspore/operations.rst | 2 -- 2 files changed, 4 deletions(-) diff --git a/docs/api_python/source_en/mindspore/operations.rst b/docs/api_python/source_en/mindspore/operations.rst index 4dcc5a82e9..730e751eeb 100644 --- a/docs/api_python/source_en/mindspore/operations.rst +++ b/docs/api_python/source_en/mindspore/operations.rst @@ -51,8 +51,6 @@ Neural Network Operators mindspore.ops.FastGeLU mindspore.ops.Flatten mindspore.ops.FloorMod - mindspore.ops.FusedBatchNorm - mindspore.ops.FusedBatchNormEx mindspore.ops.FusedSparseAdam mindspore.ops.FusedSparseLazyAdam mindspore.ops.FusedSparseProximalAdagrad diff --git a/docs/api_python/source_zh_cn/mindspore/operations.rst b/docs/api_python/source_zh_cn/mindspore/operations.rst index 4dcc5a82e9..730e751eeb 100644 --- a/docs/api_python/source_zh_cn/mindspore/operations.rst +++ b/docs/api_python/source_zh_cn/mindspore/operations.rst @@ -51,8 +51,6 @@ Neural Network Operators mindspore.ops.FastGeLU mindspore.ops.Flatten mindspore.ops.FloorMod - mindspore.ops.FusedBatchNorm - mindspore.ops.FusedBatchNormEx mindspore.ops.FusedSparseAdam mindspore.ops.FusedSparseLazyAdam mindspore.ops.FusedSparseProximalAdagrad -- Gitee From 21d368d9de65ad753f33e13bad75d428a535f8f9 Mon Sep 17 00:00:00 2001 From: yingchen Date: Thu, 18 Mar 2021 18:20:55 +0800 Subject: [PATCH 05/79] sync pr 2984 --- docs/programming_guide/source_en/run.md | 1 + docs/programming_guide/source_en/train.md | 39 ++++++++++++------- .../source_en/quick_start/quick_start.md | 2 + .../source_en/use/load_dataset_text.md | 27 ++++++++++--- 4 files changed, 49 insertions(+), 20 deletions(-) diff --git a/docs/programming_guide/source_en/run.md b/docs/programming_guide/source_en/run.md index 33179b18e8..8f387213d3 100644 --- a/docs/programming_guide/source_en/run.md +++ b/docs/programming_guide/source_en/run.md @@ -250,6 +250,7 @@ epoch: 1 step: 1875, loss is 0.017264696 ``` > Use the PyNative mode for debugging, including the execution of single operator, common function, and network training model. For details, see [Debugging in PyNative Mode](https://www.mindspore.cn/tutorial/training/en/master/advanced_use/debug_in_pynative_mode.html). +> To use free control loop iterations, traversing data sets, etc., you can refer to the "Customizing a Training Cycle" part of the official website programming guide "[Training](https://www.mindspore.cn/doc/programming_guide/en/master/train.html#customizing-a-training-cycle)". ### Executing an Inference Model diff --git a/docs/programming_guide/source_en/train.md b/docs/programming_guide/source_en/train.md index 1de44dbf01..3cdcc274b6 100644 --- a/docs/programming_guide/source_en/train.md +++ b/docs/programming_guide/source_en/train.md @@ -85,7 +85,7 @@ The output is as follows: ## Customizing a Training Cycle -If you do not want to use the `Model` interface provided by MindSpore, you can use the `train` interface to control the number of iterations and the number of steps for each epoch. +If you do not want to use the `Model` interface provided by MindSpore, you can also refer to the following examples to freely control the number of iterations, traverse the data set, and so on. The following is a code example: @@ -227,7 +227,7 @@ class TrainOneStepCell(nn.Cell): if __name__ == "__main__": - context.set_context(mode=context.GRAPH_MODE, device_target="Ascend") + 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) @@ -241,7 +241,7 @@ if __name__ == "__main__": print("============== Starting Training ==============") epoch = 10 for step in range(epoch): - for inputs in dataset_helper: + for inputs in ds_train: output = net(*inputs) print("epoch: {0}/{1}, losses: {2}".format(step + 1, epoch, output.asnumpy(), flush=True)) ``` @@ -250,17 +250,26 @@ if __name__ == "__main__": The output is as follows: -```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 +```text +============== Starting Training ============== +epoch: 1/10, losses: 2.3086986541748047 +epoch: 1/10, losses: 2.309938430786133 +epoch: 1/10, losses: 2.302298069000244 +epoch: 1/10, losses: 2.310209035873413 +epoch: 1/10, losses: 2.3002336025238037 +epoch: 1/10, losses: 2.3022992610931396 +... ... +epoch: 1/10, losses: 0.18848800659179688 +epoch: 1/10, losses: 0.15532201528549194 +epoch: 2/10, losses: 0.179201140999794 +epoch: 2/10, losses: 0.20995387434959412 +epoch: 2/10, losses: 0.4867479205131531 +... ... +epoch: 10/10, losses: 0.027243722230196 +epoch: 10/10, losses: 0.07665436714887619 +epoch: 10/10, losses: 0.005962767638266087 +epoch: 10/10, losses: 0.026364721357822418 +epoch: 10/10, losses: 0.0003102901973761618 ``` > The typical application scenario is gradient accumulation. For details, see [Applying Gradient Accumulation Algorithm](https://www.mindspore.cn/tutorial/training/en/master/advanced_use/apply_gradient_accumulation.html). @@ -419,7 +428,7 @@ class LeNet5(nn.Cell): if __name__ == "__main__": - context.set_context(mode=context.GRAPH_MODE, device_target="Ascend") + 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) diff --git a/tutorials/training/source_en/quick_start/quick_start.md b/tutorials/training/source_en/quick_start/quick_start.md index f9ad22b345..af3dc1d573 100644 --- a/tutorials/training/source_en/quick_start/quick_start.md +++ b/tutorials/training/source_en/quick_start/quick_start.md @@ -490,6 +490,8 @@ After training, multiple model files will be generated and saved under the pre-s The meaning of the file name: `{Customized name configured in ModelCheckpoint}-{The number of epoch}-{The number of step}`. +> To use free control loop iterations, traversing data sets, etc., you can refer to the "Customizing a Training Cycle" part of the official website programming guide "[Training](https://www.mindspore.cn/doc/programming_guide/en/master/train.html#customizing-a-training-cycle)". + ### Checking the Loss Value of the Model with the Change of Training Steps ```python diff --git a/tutorials/training/source_en/use/load_dataset_text.md b/tutorials/training/source_en/use/load_dataset_text.md index 7fde26bb2e..440a3e6595 100644 --- a/tutorials/training/source_en/use/load_dataset_text.md +++ b/tutorials/training/source_en/use/load_dataset_text.md @@ -33,11 +33,24 @@ This tutorial briefly demonstrates how to load and process text data using MindS 我喜欢English! ``` -2. Create the `tokenizer.txt` file, copy the text data to the file, and save the file under `./test` directory. The directory structure is as follow. +2. Create the `tokenizer.txt` file, copy the text data to the file, and save the file under `./datasets` directory. The directory structure is as follow. + + ```python + import os + + if not os.path.exists('./datasets'): + os.mkdir('./datasets') + file_handle=open('./datasets/tokenizer.txt',mode='w') + file_handle.write('Welcome to Beijing \n北京欢迎您！ \n我喜欢English! \n') + file_handle.close() + ! tree ./datasets + ``` ```text - └─test - └─tokenizer.txt + ./datasets + └── tokenizer.txt + + 0 directories, 1 file ``` 3. Import the `mindspore.dataset` and `mindspore.dataset.text` modules. @@ -49,14 +62,14 @@ This tutorial briefly demonstrates how to load and process text data using MindS ## Loading Dataset -MindSpore supports loading common datasets in the field of text processing that come in a variety of on-disk formats. Users can also implement custom dataset class to load customized data. +MindSpore supports loading common datasets in the field of text processing that come in a variety of on-disk formats. Users can also implement custom dataset class to load customized data. For detailed loading methods of various datasets, please refer to the [Loading Dataset](https://www.mindspore.cn/doc/programming_guide/en/master/dataset_loading.html) chapter in the Programming Guide. The following tutorial demonstrates loading datasets using the `TextFileDataset` in the `mindspore.dataset` module. 1. Configure the dataset directory as follows and create a dataset object. ```python - DATA_FILE = "./test/tokenizer.txt" + DATA_FILE = "./datasets/tokenizer.txt" dataset = ds.TextFileDataset(DATA_FILE, shuffle=False) ``` @@ -77,6 +90,8 @@ The following tutorial demonstrates loading datasets using the `TextFileDataset` ## Processing Data +For the data processing operators currently supported by MindSpore and their detailed usage methods, please refer to the [Processing Data](https://www.mindspore.cn/doc/programming_guide/en/master/pipeline.html) chapter in the Programming Guide + The following tutorial demonstrates how to construct a pipeline and perform operations such as `shuffle` and `RegexReplace` on the text dataset. 1. Shuffle the dataset. @@ -119,6 +134,8 @@ The following tutorial demonstrates how to construct a pipeline and perform oper ## Tokenization +For the data tokenization operators currently supported by MindSpore and their detailed usage methods, please refer to the [Tokenizer](https://www.mindspore.cn/doc/programming_guide/en/master/tokenizer.html) chapter in the Programming Guide. + The following tutorial demonstrates how to use the `WhitespaceTokenizer` to tokenize words with space. 1. Create a `tokenizer`. -- Gitee From 5fe2cbf9c9ad40006aa2158e3d7898bd564235d7 Mon Sep 17 00:00:00 2001 From: chengxiaoli Date: Thu, 18 Mar 2021 18:37:39 +0800 Subject: [PATCH 06/79] Modify the r1.1 branch FAQ document. --- docs/faq/source_en/index.rst | 1 + docs/faq/source_en/platform_and_system.md | 12 ++++++++ docs/faq/source_en/supported_operators.md | 6 ++++ docs/faq/source_en/usage_migrate_3rd.md | 34 ++++++++++++++++++++++ docs/faq/source_zh_cn/usage_migrate_3rd.md | 4 +-- 5 files changed, 55 insertions(+), 2 deletions(-) create mode 100644 docs/faq/source_en/usage_migrate_3rd.md diff --git a/docs/faq/source_en/index.rst b/docs/faq/source_en/index.rst index c08f8a005d..9df80bfc87 100644 --- a/docs/faq/source_en/index.rst +++ b/docs/faq/source_en/index.rst @@ -15,6 +15,7 @@ MindSpore FAQ network_models platform_and_system backend_running + usage_migrate_3rd programming_language_extensions supported_features mindinsight_use diff --git a/docs/faq/source_en/platform_and_system.md b/docs/faq/source_en/platform_and_system.md index cdb6b4ec8b..1b4b998664 100644 --- a/docs/faq/source_en/platform_and_system.md +++ b/docs/faq/source_en/platform_and_system.md @@ -4,6 +4,18 @@ +**Q: What is the difference between the PyNative and Graph modes?** + +A: In terms of efficiency, operators used in the two modes are the same. Therefore, when the same network and operators are executed in the two modes, the accuracy is the same. The network execution performance varies according to the execution mechanism. Theoretically, operators provided by MindSpore support both the PyNative and Graph modes. + +In terms of application scenarios, Graph mode requires the network structure to be built at the beginning, and then the framework performs entire graph optimization and execution. This mode is suitable to scenarios where the network is fixed and high performance is required. + +The two modes are supported on different hardware (such as `Ascend`, `GPU`, and `CPU`). + +In terms of code debugging, operators are executed line by line. Therefore, you can directly debug the Python code and view the `/api` output or execution result of the corresponding operator at any breakpoint in the code. In Graph mode, the network is built but not executed in the constructor function. Therefore, you cannot obtain the output of the corresponding operator at breakpoints in the `construct` function. The output can be viewed only after the network execution is complete. + +
+ **Q: How do I perform transfer learning in PyNative mode?** A: PyNative mode is compatible with transfer learning. For more tutorial information, see [Code for Loading a Pre-Trained Model](https://www.mindspore.cn/tutorial/training/en/master/advanced_use/cv_mobilenetv2_fine_tune.html#code-for-loading-a-pre-trained-model). diff --git a/docs/faq/source_en/supported_operators.md b/docs/faq/source_en/supported_operators.md index 0d66a29a4f..185ab57991 100644 --- a/docs/faq/source_en/supported_operators.md +++ b/docs/faq/source_en/supported_operators.md @@ -4,6 +4,12 @@ +**Q: What is the function of the `TransData` operator? Can the performance be optimized?** + +A: The `TransData` operator is used in the scenario where the data formats (such as NC1HWC0) used by interconnected operators on the network are inconsistent. In this case, the framework automatically inserts the `TransData` operator to convert the data formats into the same format and then performs computation. You can consider using the `amp` for mixed-precision training. In this way, some `FP32` operations and the invocation of some `TransData` operators can be reduced. + +
+ **Q: An error occurs when the `Concat` operator concatenates tuples containing multiple tensors. An error occurs when the number of `tensor list` elements entered is greater than or equal to 192. What is a better solution (running in dynamic mode) for `Concat` to concatenate tuples containing multiple Tensors?** A: The number of tensors to be concatenated at a time cannot exceed 192 according to the bottom-layer specifications of the Ascend operator. You can try to concatenate them twice. diff --git a/docs/faq/source_en/usage_migrate_3rd.md b/docs/faq/source_en/usage_migrate_3rd.md new file mode 100644 index 0000000000..11da662c2b --- /dev/null +++ b/docs/faq/source_en/usage_migrate_3rd.md @@ -0,0 +1,34 @@ +# Migration from a Third-party Framework + + + +**Q：How do I load a pre-trained PyTorch model for fine-tuning on MindSpore?** + +A：Map parameters of PyTorch and MindSpore one by one. No unified conversion script is provided due to flexible network definitions. +Customize scripts based on scenarios. For details, see [Advanced Usage of Checkpoint](https://www.mindspore.cn/doc/programming_guide/zh-CN/master/advanced_usage_of_checkpoint.html). + +
+ +**Q：How do I convert a PyTorch `dataset` to a MindSpore `dataset`?** + +A：The custom dataset logic of MindSpore is similar to that of PyTorch. You need to define a `dataset` class containing `__init__`, `__getitem__`, and `__len__` to read your dataset, instantiate the class into an object (for example, `dataset/dataset_generator`), and transfer the instantiated object to `GeneratorDataset` (on MindSpore) or `DataLoader` (on PyTorch). Then, you are ready to load the custom dataset. MindSpore provides further `map`->`batch` operations based on `GeneratorDataset`. Users can easily add other custom operations to `map` and start `batch`. +The custom dataset of MindSpore is loaded as follows: + +```python +# 1. Perform operations such as data argumentation, shuffle, and sampler. +class Mydata: + def __init__(self): + np.random.seed(58) + self.__data = np.random.sample((5, 2)) + self.__label = np.random.sample((5, 1)) + def __getitem__(self, index): + return (self.__data[index], self.__label[index]) + def __len__(self): + return len(self.__data) +dataset_generator = Mydata() +dataset = ds.GeneratorDataset(dataset_generator, ["data", "label"], shuffle=False) +# 2. Customize data argumentation. +dataset = dataset.map(operations=pyFunc, …) +# 3. batch +dataset = dataset.batch(batch_size, drop_remainder=True) +``` \ No newline at end of file diff --git a/docs/faq/source_zh_cn/usage_migrate_3rd.md b/docs/faq/source_zh_cn/usage_migrate_3rd.md index 452c31662b..f6f87e9132 100644 --- a/docs/faq/source_zh_cn/usage_migrate_3rd.md +++ b/docs/faq/source_zh_cn/usage_migrate_3rd.md @@ -1,4 +1,4 @@ -# 第三方框架迁移使用类 +# 第三方框架迁移使用类 @@ -9,7 +9,7 @@ A：需要把PyTorch和MindSpore的参数进行一一对应，因为网络定义
-**Q：怎么将PyoTrch的`dataset`转换成MindSpore的`dataset`？** +**Q：怎么将PyTorch的`dataset`转换成MindSpore的`dataset`？** A：MindSpore和PyTorch的自定义数据集逻辑是比较类似的，需要用户先定义一个自己的`dataset`类，该类负责定义`__init__`，`__getitem__`,`__len__`来读取自己的数据集，然后将该类实例化为一个对象（如：`dataset/dataset_generator`），最后将这个实例化对象传入`GeneratorDataset`(mindspore用法)/`DataLoader`(pytorch用法)，至此即可以完成自定义数据集加载了。而mindspore在`GeneratorDataset`的基础上提供了进一步的`map`->`batch`操作，可以很方便的让用户在`map`内添加一些其他的自定义操作，并将其`batch`起来。 对应的MindSpore的自定义数据集加载如下： -- Gitee From a8dd28127bce3bad4360e0774ca783475e54f934 Mon Sep 17 00:00:00 2001 From: Zhenglong Li Date: Wed, 17 Mar 2021 15:56:52 +0800 Subject: [PATCH 07/79] Update API introduction for Dvpp module --- docs/api_cpp/source_en/dataset.md | 87 +++++++++++++++ docs/api_cpp/source_zh_cn/dataset.md | 82 ++++++++++++++ ...ti_platform_inference_ascend_310_mindir.md | 101 +++++++++++++++++- ...ti_platform_inference_ascend_310_mindir.md | 97 ++++++++++++++++- 4 files changed, 364 insertions(+), 3 deletions(-) diff --git a/docs/api_cpp/source_en/dataset.md b/docs/api_cpp/source_en/dataset.md index fb8e26148d..d63318bcc6 100644 --- a/docs/api_cpp/source_en/dataset.md +++ b/docs/api_cpp/source_en/dataset.md @@ -2,6 +2,93 @@ +## Execute + +\#include <[execute.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/include/execute.h)> + +```cpp +// shared_ptr +Execute::Execute(std::shared_ptr op, MapTargetDevice deviceType); +Execute::Execute(std::vector> ops, MapTargetDevice deviceType); + +// normal pointer +Execute::Execute(std::reference_wrapper op, MapTargetDevice deviceType); +Execute::Execute(std::vector> ops, MapTargetDevice deviceType) + +// reference_wrapper +Execute::Execute(TensorTransform *op, MapTargetDevice deviceType); +Execute::Execute(std::vector ops, MapTargetDevice deviceType); +``` + +Transform（image, text）Transform operators in eager mode executor class。Multiple constructors are supported，include shared_ptr, normal pointer and reference_wrapper. + +- Parameters + + - `op`: Single transform operator. + - `ops`: A list of transform operators. + - `deviceType`: Runtime hardware. Options are: CPU, GPU and Ascend310. + +```cpp +Status operator()(const mindspore::MSTensor &input, mindspore::MSTensor *output); +``` + +Eager mode execution API. + +- Parameters + + - `input`: Tensor before transformations. + - `output`: Tensor after transformations. + +- Returns + + Status code which indicate the execution result. + +```cpp +std::string Execute::AippCfgGenerator() +``` + +Aipp module config file generator, Aipp module binds with Dvpp module. This API takes effects on case `deviceType = kAscend310`, generates Aipp config file according to the parameters of operators defined in data pre-processing. + +- Parameters + + None. + +- Returns + + Return a string indicates the system path of Aipp config file. + +## Dvpp Module + +Dvpp module is a hardware decoder embedded in Ascend 310 AI chip which has a better performance on image processing compare with CPU operators. Several transforms applied on JPEG format image are supported. + +- If let `deviceType = kAscend310` when constructing `execute` object, Dvpp operators will be applied during runtime. +- Dvpp module supporting transforms list: `Decode(), Resize(), CenterCrop(), Normalize()`. +- The above Dvpp operator and the CPU operator of the same function share a unified API, which is only distinguished by `deviceType`. + +Example: + +```cpp +// Define dvpp transforms +std::vector crop_paras = {224, 224}; + +std::vector resize_paras = {256}; + +std::vector mean = {0.485 * 255, 0.456 * 255, 0.406 * 255}; + +std::vector std = {0.229 * 255, 0.224 * 255, 0.225 * 255}; + +std::shared_ptr decode(new vision::Decode()); + +std::shared_ptr resize(new vision::Resize(resize_paras)); + +std::shared_ptr centercrop(new vision::CenterCrop(crop_paras)); + +std::shared_ptr normalize(new vision::Normalize(mean, std)); + +std::vector> trans_list = {decode, resize, centercrop, normalize}; +mindspore::dataset::Execute Transform(trans_list, MapTargetDevice::kAscend310); +``` + ## ResizeBilinear \#include <[image_process.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.h)> diff --git a/docs/api_cpp/source_zh_cn/dataset.md b/docs/api_cpp/source_zh_cn/dataset.md index 730c9e3b59..6ef534f372 100644 --- a/docs/api_cpp/source_zh_cn/dataset.md +++ b/docs/api_cpp/source_zh_cn/dataset.md @@ -2,6 +2,88 @@ +## Execute + +\#include <[execute.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/include/execute.h)> + +```cpp +// shared_ptr +Execute::Execute(std::shared_ptr op, MapTargetDevice deviceType); +Execute::Execute(std::vector> ops, MapTargetDevice deviceType); + +// normal pointer +Execute::Execute(std::reference_wrapper op, MapTargetDevice deviceType); +Execute::Execute(std::vector> ops, MapTargetDevice deviceType) + +// reference_wrapper +Execute::Execute(TensorTransform *op, MapTargetDevice deviceType); +Execute::Execute(std::vector ops, MapTargetDevice deviceType); +``` + +Transform（图像、文本）变换算子Eager模式执行类。支持多种构造函数形式，包括智能指针，普通指针以及引用封装。 + +- 参数 + + - `op`: 指定单个使用的变换算子。 + - `ops`: 指定一个列表，包含多个使用的变换算子。 + - `deviceType`: 指定运行硬件设备，选项为CPU，GPU以及Ascend 310。 + +```cpp +Status operator()(const mindspore::MSTensor &input, mindspore::MSTensor *output); +``` + +Eager模式执行接口。 + +- 参数 + + - `input`: 待变换的Tensor张量。 + - `output`: 变换后的Tensor张量。 + +- 返回值 + + 返回一个状态码指示执行变换是否成功。 + +```cpp +std::string Execute::AippCfgGenerator() +``` + +与Dvpp相关的Aipp配置文件生成器。 +该接口在`deviceType = kAscend310`时生效，依据数据预处理算子的参数自动生成Ascend 310内置Aipp模块推理配置文件。 + +- 参数 + + 无。 + +- 返回值 + + 返回一个`string`表示Aipp配置文件的系统路径。 + +## Dvpp模块 + +Dvpp模块为Ascend 310芯片内置硬件解码器，相较于CPU拥有对图形处理更强劲的性能。支持JPEG图片的解码缩放等基础操作。 + +- 定义`execute`对象时，若设置`deviceType = kAscend310`则会调用Dvpp模块执行数据预处理算子。 +- 当前Dvpp模块支持`Decode()`， `Resize()`， `CenterCrop()`， `Normalize()`。 +- 上述Dvpp算子与同功能CPU算子共用统一API，仅以`deviceType`区分。 + +示例代码： + +```cpp +// Define dvpp transforms +std::vector crop_paras = {224, 224}; +std::vector resize_paras = {256}; +std::vector mean = {0.485 * 255, 0.456 * 255, 0.406 * 255}; +std::vector std = {0.229 * 255, 0.224 * 255, 0.225 * 255}; + +std::shared_ptr decode(new vision::Decode()); +std::shared_ptr resize(new vision::Resize(resize_paras)); +std::shared_ptr centercrop(new vision::CenterCrop(crop_paras)); +std::shared_ptr normalize(new vision::Normalize(mean, std)); + +std::vector> trans_list = {decode, resize, centercrop, normalize}; +mindspore::dataset::Execute Transform(trans_list, MapTargetDevice::kAscend310); +``` + ## ResizeBilinear \#include <[image_process.h](https://gitee.com/mindspore/mindspore/blob/master/mindspore/ccsrc/minddata/dataset/kernels/image/lite_cv/image_process.h)> diff --git a/tutorials/inference/source_en/multi_platform_inference_ascend_310_mindir.md b/tutorials/inference/source_en/multi_platform_inference_ascend_310_mindir.md index 2a3a435465..5e6e680c6c 100644 --- a/tutorials/inference/source_en/multi_platform_inference_ascend_310_mindir.md +++ b/tutorials/inference/source_en/multi_platform_inference_ascend_310_mindir.md @@ -63,6 +63,8 @@ Create a directory to store the inference code project, for example, `/home/HwHi ## Inference Code +### Data-preprocessing by CPU operators + Inference sample code: . Using namespace of `mindspore` and `mindspore::dataset`. @@ -72,7 +74,7 @@ namespace ms = mindspore; namespace ds = mindspore::dataset; ``` -Set global context, device target is `Ascend310` and evice id is `0`: +Set global context, device target is `Ascend 310` and device id is `0`: ```c++ ms::GlobalContext::SetGlobalDeviceTarget(ms::kDeviceTypeAscend310); @@ -103,7 +105,7 @@ ms::MSTensor ReadFile(const std::string &file); auto image = ReadFile(image_file); ``` -Image preprocess: +Image preprocess(CPU operators): ```c++ // Create the CPU operator provided by MindData to get the function object @@ -147,6 +149,101 @@ Print the result: std::cout << "Image: " << image_file << " infer result: " << GetMax(outputs[0]) << std::endl; ``` +### Data pre-processing by Ascend 310 operators + +Dvpp module is a hardware decoder embedded in Ascend 310 AI chip which has a better performance on image processing compare with CPU operators. Several transforms applied on JPEG format image are supported. + +Using namespace of `mindspore` and `mindspore::dataset`. + +```c++ +namespace ms = mindspore; +namespace ds = mindspore::dataset; +``` + +Set global context, device target is `Ascend 310` and device id is `0`: + +```c++ +ms::GlobalContext::SetGlobalDeviceTarget(ms::kDeviceTypeAscend310); +ms::GlobalContext::SetGlobalDeviceID(0); +``` + +Load image file: + +```c++ +// Readfile is a function to read images +ms::MSTensor ReadFile(const std::string &file); +auto image = ReadFile(image_file); +``` + +Image preprocess(Ascend 310 operators): + +```c++ +// Create the CPU operator provided by MindData to get the function object + +// Decode the input to YUV420 format +std::shared_ptr decode(new ds::vision::Decode()); +// Resize the image to the given size +std::shared_ptr resize(new ds::vision::Resize({256})); +// Normalize the input +std::shared_ptr normalize(new ds::vision::Normalize( + {0.485 * 255, 0.456 * 255, 0.406 * 255}, {0.229 * 255, 0.224 * 255, 0.225 * 255})); +// Crop the input image at the center +std::shared_ptr center_crop(new ds::vision::CenterCrop({224, 224})); +``` + +Image preprocess (Ascend 310 operators, 130% performance increasing compare to CPU operators). + +Explicitly specify the computing hardware as Ascend 310. + +```c++ +// Define a MindData preprocessor, set deviceType = kAscend310 +ds::Execute preprocessor({decode, resize, center_crop, normalize}, MapTargetDevice::kAscend310); + +// Call the function object to get the processed image +ret = preprocessor(image, &image); +``` + +Load mindir file: Ascend 310 operators must bind with Aipp module, insert Aipp module for model graph compiling. + + ```c++ +// Load MindIR model +auto graph = ms::Serialization::LoadModel(resnet_file, ms::ModelType::kMindIR); + +auto model_context = std::make_shared(); + +ms::ModelContext::SetInsertOpConfigPath(model_context, preprocessor.AippCfgGenerator()); + +// Build model with graph object +ms::Model resnet50(ms::GraphCell(graph), model_context); +ms::Status ret = resnet50.Build(); + ``` + +Get input information of this model: + +```c++ +std::vector model_inputs = resnet50.GetInputs(); +``` + +Execute the model: + +```c++ +// Create outputs vector +std::vector outputs; +// Create inputs vector +std::vector inputs; +inputs.emplace_back(model_inputs[0].Name(), model_inputs[0].DataType(), model_inputs[0].Shape(), + image.Data().get(), image.DataSize()); +// Call the Predict function of Model for inference +ret = resnet50.Predict(inputs, &outputs); +``` + +Print the result: + +```c++ +// Output the maximum probability to the screen +std::cout << "Image: " << image_file << " infer result: " << GetMax(outputs[0]) << std::endl; +``` + ## Introduce to Building Script The building script is used to building applications: . diff --git a/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310_mindir.md b/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310_mindir.md index 7958b91e6e..2a34971376 100644 --- a/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310_mindir.md +++ b/tutorials/inference/source_zh_cn/multi_platform_inference_ascend_310_mindir.md @@ -63,6 +63,8 @@ Ascend 310是面向边缘场景的高能效高集成度AI处理器。Atlas 200 ## 推理代码介绍 +### 使用CPU算子数据预处理 + 推理代码样例： 。 引用`mindspore`和`mindspore::dataset`的名字空间。 @@ -103,7 +105,7 @@ ms::MSTensor ReadFile(const std::string &file); auto image = ReadFile(image_file); ``` -图片预处理: +图片预处理（使用CPU算子）: ```c++ // Create the CPU operator provided by MindData to get the function object @@ -147,6 +149,99 @@ ret = resnet50.Predict(inputs, &outputs); std::cout << "Image: " << image_file << " infer result: " << GetMax(outputs[0]) << std::endl; ``` +### 使用Ascend 310算子数据预处理 + +Dvpp模块为Ascend 310芯片内置硬件解码器，相较于CPU拥有对图形处理更强劲的性能。支持JPEG图片的解码缩放等基础操作。 + +引用`mindspore`和`mindspore::dataset`的名字空间。 + +```c++ +namespace ms = mindspore; +namespace ds = mindspore::dataset; +``` + +环境初始化，指定硬件为Ascend 310，DeviceID为0： + +```c++ +ms::GlobalContext::SetGlobalDeviceTarget(ms::kDeviceTypeAscend310); +ms::GlobalContext::SetGlobalDeviceID(0); +``` + +加载图片文件: + +```c++ +// Readfile is a function to read images +ms::MSTensor ReadFile(const std::string &file); +auto image = ReadFile(image_file); +``` + +图片预处理（使用Ascend 310算子）: + +```c++ +// Create the Dvpp operator provided by MindData to get the function object + +// Decode the input to YUV420 format +std::shared_ptr decode(new ds::vision::Decode()); +// Resize the image to the given size +std::shared_ptr resize(new ds::vision::Resize({256})); +// Normalize the input +std::shared_ptr normalize(new ds::vision::Normalize( + {0.485 * 255, 0.456 * 255, 0.406 * 255}, {0.229 * 255, 0.224 * 255, 0.225 * 255})); +// Crop the input image at the center +std::shared_ptr center_crop(new ds::vision::CenterCrop({224, 224})); +``` + +图片预处理（使用Ascend 310算子， 性能为CPU算子的2.3倍），需显式指定计算硬件为Ascend 310。 + +```c++ +// Define a MindData preprocessor, set deviceType = kAscend310 +ds::Execute preprocessor({decode, resize, center_crop, normalize}, MapTargetDevice::kAscend310); + +// Call the function object to get the processed image +ret = preprocessor(image, &image); +``` + +加载模型文件: 若使用Ascend 310算子，则需要为模型插入Aipp算子。 + +```c++ +// Load MindIR model +auto graph = ms::Serialization::LoadModel(resnet_file, ms::ModelType::kMindIR); + +auto model_context = std::make_shared(); + +ms::ModelContext::SetInsertOpConfigPath(model_context, preprocessor.AippCfgGenerator()); + +// Build model with graph object +ms::Model resnet50(ms::GraphCell(graph), model_context); +ms::Status ret = resnet50.Build(); +``` + +获取模型所需输入信息： + +```c++ +std::vector model_inputs = resnet50.GetInputs(); +``` + +执行推理: + +```c++ +// Create outputs vector +std::vector outputs; +// Create inputs vector +std::vector inputs; +inputs.emplace_back(model_inputs[0].Name(), model_inputs[0].DataType(), model_inputs[0].Shape(), + image.Data().get(), image.DataSize()); +// Call the Predict function of Model for inference +ret = resnet50.Predict(inputs, &outputs); +``` + +获取推理结果: + +```c++ +// Output the maximum probability to the screen +std::cout << "Image: " << image_file << " infer result: " << GetMax(outputs[0]) << std::endl; +``` + ## 构建脚本介绍 构建脚本用于构建用户程序，样例来自于： 。 -- Gitee From 3e21cfa8d0a56d81e359c17d7f686cfe2da7b058 Mon Sep 17 00:00:00 2001 From: wilfChen Date: Fri, 19 Mar 2021 09:32:35 +0800 Subject: [PATCH 08/79] serving gpu doc --- tutorials/inference/source_en/serving_example.md | 2 +- tutorials/inference/source_en/serving_grpc.md | 2 +- tutorials/inference/source_en/serving_model.md | 2 +- tutorials/inference/source_en/serving_restful.md | 2 +- tutorials/inference/source_zh_cn/serving_example.md | 2 +- tutorials/inference/source_zh_cn/serving_grpc.md | 2 +- tutorials/inference/source_zh_cn/serving_model.md | 2 +- tutorials/inference/source_zh_cn/serving_restful.md | 2 +- 8 files changed, 8 insertions(+), 8 deletions(-) diff --git a/tutorials/inference/source_en/serving_example.md b/tutorials/inference/source_en/serving_example.md index 18c4d46716..8dfdf99afd 100644 --- a/tutorials/inference/source_en/serving_example.md +++ b/tutorials/inference/source_en/serving_example.md @@ -1,6 +1,6 @@ # MindSpore Serving-based Inference Service Deployment -`Linux` `Ascend` `Serving` `Beginner` `Intermediate` `Expert` +`Linux` `Ascend` `Serving` `GPU` `Beginner` `Intermediate` `Expert` diff --git a/tutorials/inference/source_en/serving_grpc.md b/tutorials/inference/source_en/serving_grpc.md index 705d67307e..6ac0bcd706 100644 --- a/tutorials/inference/source_en/serving_grpc.md +++ b/tutorials/inference/source_en/serving_grpc.md @@ -1,6 +1,6 @@ # gRPC-based MindSpore Serving Access -`Linux` `Ascend` `Serving` `Beginner` `Intermediate` `Expert` +`Linux` `Ascend` `GPU` `Serving` `Beginner` `Intermediate` `Expert` diff --git a/tutorials/inference/source_en/serving_model.md b/tutorials/inference/source_en/serving_model.md index 36e8d6c784..b2c5ba4b70 100644 --- a/tutorials/inference/source_en/serving_model.md +++ b/tutorials/inference/source_en/serving_model.md @@ -1,6 +1,6 @@ # Servable Provided Through Model Configuration -`Linux` `Ascend` `Serving` `Beginner` `Intermediate` `Expert` +`Linux` `Ascend` `GPU` `Serving` `Beginner` `Intermediate` `Expert` diff --git a/tutorials/inference/source_en/serving_restful.md b/tutorials/inference/source_en/serving_restful.md index 4c8cae4f9b..27f1e70b87 100644 --- a/tutorials/inference/source_en/serving_restful.md +++ b/tutorials/inference/source_en/serving_restful.md @@ -1,6 +1,6 @@ # RESTful-based MindSpore Serving Access -`Linux` `Serving` `Ascend` `Beginner` `Intermediate` `Expert` +`Linux` `Serving` `Ascend` `GPU` `Beginner` `Intermediate` `Expert` diff --git a/tutorials/inference/source_zh_cn/serving_example.md b/tutorials/inference/source_zh_cn/serving_example.md index eb551efba2..428ad0b8aa 100644 --- a/tutorials/inference/source_zh_cn/serving_example.md +++ b/tutorials/inference/source_zh_cn/serving_example.md @@ -1,6 +1,6 @@ # 基于MindSpore Serving部署推理服务 -`Linux` `Ascend` `Serving` `初级` `中级` `高级` +`Linux` `Ascend` `GPU` `Serving` `初级` `中级` `高级` diff --git a/tutorials/inference/source_zh_cn/serving_grpc.md b/tutorials/inference/source_zh_cn/serving_grpc.md index 3e6af816a3..1ea28a23be 100644 --- a/tutorials/inference/source_zh_cn/serving_grpc.md +++ b/tutorials/inference/source_zh_cn/serving_grpc.md @@ -1,6 +1,6 @@ # 基于gRPC接口访问MindSpore Serving服务 -`Linux` `Ascend` `Serving` `初级` `中级` `高级` +`Linux` `Ascend` `GPU` `Serving` `初级` `中级` `高级` diff --git a/tutorials/inference/source_zh_cn/serving_model.md b/tutorials/inference/source_zh_cn/serving_model.md index fbcff9572d..1db3cb93e6 100644 --- a/tutorials/inference/source_zh_cn/serving_model.md +++ b/tutorials/inference/source_zh_cn/serving_model.md @@ -1,6 +1,6 @@ # 通过配置模型提供Servable -`Linux` `Ascend` `Serving` `初级` `中级` `高级` +`Linux` `Ascend` `GPU` `Serving` `初级` `中级` `高级` diff --git a/tutorials/inference/source_zh_cn/serving_restful.md b/tutorials/inference/source_zh_cn/serving_restful.md index b61e965310..61b672849c 100644 --- a/tutorials/inference/source_zh_cn/serving_restful.md +++ b/tutorials/inference/source_zh_cn/serving_restful.md @@ -1,6 +1,6 @@ # 基于RESTful接口访问MindSpore Serving服务 -`Linux` `Serving` `Ascend` `初级` `中级` `高级` +`Linux` `Serving` `Ascend` `GPU` `初级` `中级` `高级` -- Gitee From a46f51e8c42540d3545c365b0ffa6ee81eb02886 Mon Sep 17 00:00:00 2001 From: donghufeng Date: Fri, 19 Mar 2021 12:08:59 +0800 Subject: [PATCH 09/79] functional error --- .../source_en/mindquantum/mindquantum.rst | 32 +++++++++---------- .../source_zh_cn/mindquantum/mindquantum.rst | 32 +++++++++---------- 2 files changed, 32 insertions(+), 32 deletions(-) diff --git a/docs/api_python/source_en/mindquantum/mindquantum.rst b/docs/api_python/source_en/mindquantum/mindquantum.rst index 41b1ba084d..2464675921 100644 --- a/docs/api_python/source_en/mindquantum/mindquantum.rst +++ b/docs/api_python/source_en/mindquantum/mindquantum.rst @@ -33,22 +33,22 @@ The functional gates are the pre-instantiated quantum gates, which can be used d * - functional - gates - * - mindspore.gate.CNOT - - :class:`mindspore.gate.CNOTGate` - * - mindspore.gate.I - - :class:`mindspore.gate.IGate` - * - mindspore.gate.H - - :class:`mindspore.gate.HGate` - * - mindspore.gate.S - - :class:`mindspore.gate.PhaseShift` (numpy.pi/2) - * - mindspore.gate.SWAP - - :class:`mindspore.gate.SWAPGate` - * - mindspore.gate.X - - :class:`mindspore.gate.XGate` - * - mindspore.gate.Y - - :class:`mindspore.gate.YGate` - * - mindspore.gate.Z - - :class:`mindspore.gate.ZGate` + * - mindquantum.gate.CNOT + - :class:`mindquantum.gate.CNOTGate` + * - mindquantum.gate.I + - :class:`mindquantum.gate.IGate` + * - mindquantum.gate.H + - :class:`mindquantum.gate.HGate` + * - mindquantum.gate.S + - :class:`mindquantum.gate.PhaseShift` (numpy.pi/2) + * - mindquantum.gate.SWAP + - :class:`mindquantum.gate.SWAPGate` + * - mindquantum.gate.X + - :class:`mindquantum.gate.XGate` + * - mindquantum.gate.Y + - :class:`mindquantum.gate.YGate` + * - mindquantum.gate.Z + - :class:`mindquantum.gate.ZGate` mindquantum.nn -------------- diff --git a/docs/api_python/source_zh_cn/mindquantum/mindquantum.rst b/docs/api_python/source_zh_cn/mindquantum/mindquantum.rst index 41b1ba084d..2464675921 100644 --- a/docs/api_python/source_zh_cn/mindquantum/mindquantum.rst +++ b/docs/api_python/source_zh_cn/mindquantum/mindquantum.rst @@ -33,22 +33,22 @@ The functional gates are the pre-instantiated quantum gates, which can be used d * - functional - gates - * - mindspore.gate.CNOT - - :class:`mindspore.gate.CNOTGate` - * - mindspore.gate.I - - :class:`mindspore.gate.IGate` - * - mindspore.gate.H - - :class:`mindspore.gate.HGate` - * - mindspore.gate.S - - :class:`mindspore.gate.PhaseShift` (numpy.pi/2) - * - mindspore.gate.SWAP - - :class:`mindspore.gate.SWAPGate` - * - mindspore.gate.X - - :class:`mindspore.gate.XGate` - * - mindspore.gate.Y - - :class:`mindspore.gate.YGate` - * - mindspore.gate.Z - - :class:`mindspore.gate.ZGate` + * - mindquantum.gate.CNOT + - :class:`mindquantum.gate.CNOTGate` + * - mindquantum.gate.I + - :class:`mindquantum.gate.IGate` + * - mindquantum.gate.H + - :class:`mindquantum.gate.HGate` + * - mindquantum.gate.S + - :class:`mindquantum.gate.PhaseShift` (numpy.pi/2) + * - mindquantum.gate.SWAP + - :class:`mindquantum.gate.SWAPGate` + * - mindquantum.gate.X + - :class:`mindquantum.gate.XGate` + * - mindquantum.gate.Y + - :class:`mindquantum.gate.YGate` + * - mindquantum.gate.Z + - :class:`mindquantum.gate.ZGate` mindquantum.nn -------------- -- Gitee From 071d3057f03a3de6a3787ead42d1d8f86ad1982e Mon Sep 17 00:00:00 2001 From: yingchen Date: Fri, 19 Mar 2021 14:07:26 +0800 Subject: [PATCH 10/79] fix link error --- docs/api_cpp/source_en/lite_cpp_example.rst | 1 + docs/api_cpp/source_zh_cn/lite_cpp_example.rst | 1 + 2 files changed, 2 insertions(+) diff --git a/docs/api_cpp/source_en/lite_cpp_example.rst b/docs/api_cpp/source_en/lite_cpp_example.rst index c96d72de5d..fd4d779e49 100644 --- a/docs/api_cpp/source_en/lite_cpp_example.rst +++ b/docs/api_cpp/source_en/lite_cpp_example.rst @@ -3,6 +3,7 @@ Example .. toctree:: :maxdepth: 1 + Simple Demo Implementing an Image Classification Application High-level Usage \ No newline at end of file diff --git a/docs/api_cpp/source_zh_cn/lite_cpp_example.rst b/docs/api_cpp/source_zh_cn/lite_cpp_example.rst index daad77989b..b406fdd680 100644 --- a/docs/api_cpp/source_zh_cn/lite_cpp_example.rst +++ b/docs/api_cpp/source_zh_cn/lite_cpp_example.rst @@ -3,6 +3,7 @@ .. toctree:: :maxdepth: 1 + 极简Demo 实现一个图像分类应用 高阶用法 \ No newline at end of file -- Gitee From 0d1a96ba883781faecfd9aa37d2b11da7427625a Mon Sep 17 00:00:00 2001 From: Ziyan Date: Thu, 18 Mar 2021 11:14:19 +0800 Subject: [PATCH 11/79] fix distributed grad accu doc --- .../apply_gradient_accumulation.md | 33 ++++++++--------- .../distributed_training/cell_wrapper.py | 35 +++++++++++-------- .../distributed_training/model_accu.py | 2 +- ...resnet50_distributed_training_grad_accu.py | 3 +- 4 files changed, 39 insertions(+), 34 deletions(-) diff --git a/tutorials/training/source_zh_cn/advanced_use/apply_gradient_accumulation.md b/tutorials/training/source_zh_cn/advanced_use/apply_gradient_accumulation.md index 3aa1fdb725..4559ecc8dc 100644 --- a/tutorials/training/source_zh_cn/advanced_use/apply_gradient_accumulation.md +++ b/tutorials/training/source_zh_cn/advanced_use/apply_gradient_accumulation.md @@ -15,8 +15,8 @@ - [训练并保存模型](#训练并保存模型) - [实验结果](#实验结果) - [并行模式](#并行模式) - - [定义训练流程](#定义训练流程) - - [定义训练模型](#定义训练模型) + - [定义并行训练流程](#定义并行训练流程) + - [定义并行训练模型](#定义并行训练模型) - [训练模型](#训练模型) @@ -284,7 +284,7 @@ python eval.py --data_path=./MNIST_Data --ckpt_path=./gradient_accumulation.ckpt > 你可以在这里下载主要的训练样例代码： -### 定义训练流程 +### 定义并行训练流程 通常情况下，定义了正向网络后会使用[`TrainOneStepCell`](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/nn/mindspore.nn.TrainOneStepCell.html?highlight=trainonestepcell)将网络正反向及优化器关联到一起。但是梯度累积时存在累积和更新两种情况，所以我们要基于原有类定义做一些改造。样例代码如下： @@ -316,13 +316,9 @@ class TrainAccuStepsCell(TrainOneStepCell): def __init__(self, network, optimizer, sens=1.0): super(TrainAccuStepsCell, self).__init__(network, optimizer, sens) self.accumulation = False - self.is_accu_step = Tensor(np.array([self.accumulation])) self.accumulation_steps = context.get_auto_parallel_context("grad_accumulation_step") - self.one = Tensor(np.array([1]).astype(np.int32)) - self.zero = Tensor(np.array([0]).astype(np.int32)) self.accu_grads = self.weights.clone(prefix="accu_grads", init='zeros') - self.accu_overflow = Parameter(initializer(0, [1], mstype.int32)) - self.accu_loss = Parameter(initializer(0, [1], mstype.float32)) + self.hyper_map = ops.HyperMap() def construct(self, *inputs): """Defines the computation performed.""" @@ -330,16 +326,16 @@ class TrainAccuStepsCell(TrainOneStepCell): loss = self.network(*inputs) sens = ops.Fill()(ops.DType()(loss), ops.Shape()(loss), self.sens) grads = self.grad(self.network, weights)(*inputs, sens) - if self.is_accu_step and self.accumulation_steps > 1: + if self.accumulation and self.accumulation_steps > 1: accu_succ = self.hyper_map(update_accu_grads, self.accu_grads, grads) loss = ops.depend(loss, accu_succ) - if self.is_accu_step: + if self.accumulation: succ = False else: grads = self.grad_reducer(grads) accu_grads = ops.depend(self.accu_grads, grads) accu_succ = self.hyper_map(reset_accu_grads, accu_grads) - ops.depend(loss, accu_succ) + loss = ops.depend(loss, accu_succ) succ = self.optimizer(grads) return ops.depend(loss, succ) ``` @@ -375,6 +371,7 @@ def _update_accu_grads(accu_grad, grad): succ = True return ops.depend(succ, ops.assign_add(accu_grad, cast(grad, mstype.float32))) + class TrainAccuStepsWithLossScaleCell(TrainOneStepWithLossScaleCell): def __init__(self, network, optimizer, scale_sense): super(TrainAccuStepsWithLossScaleCell, self).__init__(network, optimizer, scale_sense) @@ -396,14 +393,14 @@ class TrainAccuStepsWithLossScaleCell(TrainOneStepWithLossScaleCell): weights = self.weights loss = self.network(*inputs) scaling_sens = self.scale_sense - status, scaling_sens = self.start_overflow(loss, scaling_sens) + status, scaling_sens = self.start_overflow_check(loss, scaling_sens) scaling_sens_filled = ops.ones_like(loss) * ops.cast(scaling_sens, ops.dtype(loss)) grads = self.grad(self.network, weights)(*inputs, scaling_sens_filled) # accumulate gradients if self.accumulation and self.accumulation_steps > 1: accu_succ = self.hyper_map(update_accu_grads, self.accu_grads, grads) loss = ops.depend(loss, accu_succ) - overflow = self.detect_overflow(status, grads) + overflow = self.get_overflow_status(status, grads) overflow = self.logical_or(self.not_equal(self.accu_overflow, self.zero), overflow) accu_overflow = self.select(overflow, self.one, self.zero) @@ -414,9 +411,8 @@ class TrainAccuStepsWithLossScaleCell(TrainOneStepWithLossScaleCell): self.accu_overflow = self.zero # apply grad reducer on grads grads = self.grad_reducer(grads) - scaling = scaling_sens * self.degree - grads = self.hyper_map(ops.partial(_grad_scale, scaling), grads) - accu_overflow = self.overflow_reducer(accu_overflow) + grads = self.hyper_map(ops.partial(_grad_scale, scaling_sens), grads) + accu_overflow = self.allreduce(accu_overflow) overflow = self.less_equal(self.base, accu_overflow) accu_grads = ops.depend(self.accu_grads, grads) accu_succ = self.hyper_map(reset_accu_grads, accu_grads) @@ -434,7 +430,7 @@ class TrainAccuStepsWithLossScaleCell(TrainOneStepWithLossScaleCell): 其中`accu_overflow`是专门用来保存累积溢出标志位的参数。 -### 定义训练模型 +### 定义并行训练模型 经过`cell_wrapper`封装的网络已经包含了正反向和优化器实现，我们还需要将数据集对接到网络并实现两张图交替执行。这里基于框架中的[`Model`](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/mindspore.html?highlight=model#mindspore.Model)接口实现上述功能。 @@ -575,7 +571,7 @@ class Model_ACCU(Model): else: cb_params.cur_step_num += iter_first_order if train_network_init_flag: - self._train_network.add_flags_recursive(accumulation=True) + self._train_network.add_flags_recursive(accumulation=False) train_network_init_flag = False self._train_network.phase = 'train1' if not has_do_dataset_init: @@ -612,6 +608,7 @@ net = resnet50(batch_size, num_classes) loss = SoftmaxCrossEntropyExpand(sparse=True) opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01, 0.9) net_with_loss = nn.WithLossCell(net, loss) +net_with_loss = VirtualDatasetCell(net_with_loss) wrap_net = TrainAccuStepsCell(net_with_loss, opt) model = Model_ACCU(wrap_net) model.train(epoch_size, dataset, callbacks=[loss_cb], dataset_sink_mode=True) diff --git a/tutorials/tutorial_code/distributed_training/cell_wrapper.py b/tutorials/tutorial_code/distributed_training/cell_wrapper.py index 9d5d3ff88e..47c277a8ed 100644 --- a/tutorials/tutorial_code/distributed_training/cell_wrapper.py +++ b/tutorials/tutorial_code/distributed_training/cell_wrapper.py @@ -18,9 +18,10 @@ grad accumulation cell wrapper import numpy as np import mindspore.common.dtype as mstype from mindspore import ops, context, Tensor, Parameter -from mindspore.nn import TrainOneStepCell, TrainOneStepWithLossScaleCell +from mindspore.nn import Cell, TrainOneStepCell, TrainOneStepWithLossScaleCell from mindspore.nn.wrap.loss_scale import _grad_scale from mindspore.common.initializer import initializer +from mindspore.ops.operations.comm_ops import _VirtualDataset zeroslike = ops.ZerosLike() reset_accu_grads = ops.MultitypeFuncGraph("reset_accu_grads") @@ -44,13 +45,9 @@ class TrainAccuStepsCell(TrainOneStepCell): def __init__(self, network, optimizer, sens=1.0): super(TrainAccuStepsCell, self).__init__(network, optimizer, sens) self.accumulation = False - self.is_accu_step = Tensor(np.array([self.accumulation])) self.accumulation_steps = context.get_auto_parallel_context("grad_accumulation_step") - self.one = Tensor(np.array([1]).astype(np.int32)) - self.zero = Tensor(np.array([0]).astype(np.int32)) self.accu_grads = self.weights.clone(prefix="accu_grads", init='zeros') - self.accu_overflow = Parameter(initializer(0, [1], mstype.int32)) - self.accu_loss = Parameter(initializer(0, [1], mstype.float32)) + self.hyper_map = ops.HyperMap() def construct(self, *inputs): """Defines the computation performed.""" @@ -58,16 +55,16 @@ class TrainAccuStepsCell(TrainOneStepCell): loss = self.network(*inputs) sens = ops.Fill()(ops.DType()(loss), ops.Shape()(loss), self.sens) grads = self.grad(self.network, weights)(*inputs, sens) - if self.is_accu_step and self.accumulation_steps > 1: + if self.accumulation and self.accumulation_steps > 1: accu_succ = self.hyper_map(update_accu_grads, self.accu_grads, grads) loss = ops.depend(loss, accu_succ) - if self.is_accu_step: + if self.accumulation: succ = False else: grads = self.grad_reducer(grads) accu_grads = ops.depend(self.accu_grads, grads) accu_succ = self.hyper_map(reset_accu_grads, accu_grads) - ops.depend(loss, accu_succ) + loss = ops.depend(loss, accu_succ) succ = self.optimizer(grads) return ops.depend(loss, succ) @@ -93,14 +90,14 @@ class TrainAccuStepsWithLossScaleCell(TrainOneStepWithLossScaleCell): weights = self.weights loss = self.network(*inputs) scaling_sens = self.scale_sense - status, scaling_sens = self.start_overflow(loss, scaling_sens) + status, scaling_sens = self.start_overflow_check(loss, scaling_sens) scaling_sens_filled = ops.ones_like(loss) * ops.cast(scaling_sens, ops.dtype(loss)) grads = self.grad(self.network, weights)(*inputs, scaling_sens_filled) # accumulate gradients if self.accumulation and self.accumulation_steps > 1: accu_succ = self.hyper_map(update_accu_grads, self.accu_grads, grads) loss = ops.depend(loss, accu_succ) - overflow = self.detect_overflow(status, grads) + overflow = self.get_overflow_status(status, grads) overflow = self.logical_or(self.not_equal(self.accu_overflow, self.zero), overflow) accu_overflow = self.select(overflow, self.one, self.zero) @@ -111,9 +108,8 @@ class TrainAccuStepsWithLossScaleCell(TrainOneStepWithLossScaleCell): self.accu_overflow = self.zero # apply grad reducer on grads grads = self.grad_reducer(grads) - scaling = scaling_sens * self.degree - grads = self.hyper_map(ops.partial(_grad_scale, scaling), grads) - accu_overflow = self.overflow_reducer(accu_overflow) + grads = self.hyper_map(ops.partial(_grad_scale, scaling_sens), grads) + accu_overflow = self.allreduce(accu_overflow) overflow = self.less_equal(self.base, accu_overflow) accu_grads = ops.depend(self.accu_grads, grads) accu_succ = self.hyper_map(reset_accu_grads, accu_grads) @@ -128,3 +124,14 @@ class TrainAccuStepsWithLossScaleCell(TrainOneStepWithLossScaleCell): ret = (loss, overflow, scaling_sens) return ops.depend(ret, succ) + +class VirtualDatasetCell(Cell): + def __init__(self, backbone): + super(VirtualDatasetCell, self).__init__(auto_prefix=False) + self._backbone = backbone + self._virtual_dataset = _VirtualDataset() + + def construct(self, *inputs): + output = self._virtual_dataset(*inputs) + return self._backbone(*output) + diff --git a/tutorials/tutorial_code/distributed_training/model_accu.py b/tutorials/tutorial_code/distributed_training/model_accu.py index 5a6d0a6011..18722cefa5 100644 --- a/tutorials/tutorial_code/distributed_training/model_accu.py +++ b/tutorials/tutorial_code/distributed_training/model_accu.py @@ -134,7 +134,7 @@ class Model_ACCU(Model): else: cb_params.cur_step_num += iter_first_order if train_network_init_flag: - self._train_network.add_flags_recursive(accumulation=True) + self._train_network.add_flags_recursive(accumulation=False) train_network_init_flag = False self._train_network.phase = 'train1' if not has_do_dataset_init: diff --git a/tutorials/tutorial_code/distributed_training/resnet50_distributed_training_grad_accu.py b/tutorials/tutorial_code/distributed_training/resnet50_distributed_training_grad_accu.py index efd800bf02..b8c4b03c78 100644 --- a/tutorials/tutorial_code/distributed_training/resnet50_distributed_training_grad_accu.py +++ b/tutorials/tutorial_code/distributed_training/resnet50_distributed_training_grad_accu.py @@ -29,7 +29,7 @@ from mindspore.context import ParallelMode from mindspore.train.callback import LossMonitor from resnet import resnet50 from model_accu import Model_ACCU -from cell_wrapper import TrainAccuStepsCell +from cell_wrapper import TrainAccuStepsCell, VirtualDatasetCell device_id = int(os.getenv('DEVICE_ID')) context.set_context(mode=context.GRAPH_MODE, device_target="Ascend") @@ -121,6 +121,7 @@ def test_train_cifar(epoch_size=10): # pylint: disable=missing-docstring loss = SoftmaxCrossEntropyExpand(sparse=True) opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01, 0.9) net_with_loss = nn.WithLossCell(net, loss) + net_with_loss = VirtualDatasetCell(net_with_loss) wrap_net = TrainAccuStepsCell(net_with_loss, opt) model = Model_ACCU(wrap_net) model.train(epoch_size, dataset, callbacks=[loss_cb], dataset_sink_mode=True) -- Gitee From 79763d130a46ead49aab9a529b78e52bf952de1b Mon Sep 17 00:00:00 2001 From: huangbo77 Date: Fri, 19 Mar 2021 14:37:52 +0800 Subject: [PATCH 12/79] updated docs for densenet --- docs/note/source_en/network_list_ms.md | 3 ++- docs/note/source_zh_cn/network_list_ms.md | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/docs/note/source_en/network_list_ms.md b/docs/note/source_en/network_list_ms.md index 8eaf23753b..7566c8c7c1 100644 --- a/docs/note/source_en/network_list_ms.md +++ b/docs/note/source_en/network_list_ms.md @@ -19,7 +19,8 @@ |:------ |:------| :----------- |:------ |:------ |:------ |:------ |:----- |:----- |Computer Vision (CV) | Image Classification | [AlexNet](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/alexnet) | Supported | Supported | Supported | Supported | Doing | Doing | Computer Vision (CV) | Image Classification | [CNN](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/cnn_direction_model) | Supported | Doing | Doing | Doing | Doing | Doing -| Computer Vision (CV) | Image Classification | [DenseNet121](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/densenet121) | Supported | Supported | Doing | Doing | Doing | Doing +| Computer Vision (CV) | Image Classification | [DenseNet100](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/densenet) | Doing | Doing | Doing | Doing | Supported | Supported +| Computer Vision (CV) | Image Classification | [DenseNet121](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/densenet) | Supported | Supported | Doing | Doing | Doing | Doing | Computer Vision (CV) | Image Classification | [EfficientNet-B0](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/efficientnet) | Doing | Doing | Supported | Supported | Doing | Doing | Computer Vision (CV) | Image Classification | [GoogLeNet](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/googlenet) | Supported | Supported | Supported | Supported | Doing | Doing | Computer Vision (CV) | Image Classification | [InceptionV3](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/inceptionv3) | Supported | Doing | Doing | Doing | Doing | Doing diff --git a/docs/note/source_zh_cn/network_list_ms.md b/docs/note/source_zh_cn/network_list_ms.md index d4685b9f0f..6568de2d72 100644 --- a/docs/note/source_zh_cn/network_list_ms.md +++ b/docs/note/source_zh_cn/network_list_ms.md @@ -19,7 +19,8 @@ |:---- |:------- |:---- |:---- |:---- |:---- |:---- |:---- |:---- |计算机视觉（CV） | 图像分类（Image Classification） | [AlexNet](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/alexnet) | Supported | Supported | Supported | Supported | Doing | Doing | 计算机视觉（CV） | 图像分类（Image Classification） | [CNN](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/cnn_direction_model) | Supported | Doing | Doing | Doing | Doing | Doing -| 计算机视觉（CV） | 图像分类（Image Classification） | [DenseNet121](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/densenet121) | Supported | Supported | Doing | Doing | Doing | Doing +| 计算机视觉（CV） | 图像分类（Image Classification） | [DenseNet100](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/densenet) | Doing | Doing | Doing | Doing | Supported | Supported +| 计算机视觉（CV） | 图像分类（Image Classification） | [DenseNet121](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/densenet) | Supported | Supported | Doing | Doing | Doing | Doing | 计算机视觉（CV） | 图像分类（Image Classification） | [EfficientNet-B0](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/efficientnet) | Doing | Doing | Supported | Supported | Doing | Doing | 计算机视觉（CV） | 图像分类（Image Classification） | [GoogLeNet](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/googlenet) | Supported | Supported | Supported | Supported | Doing | Doing | 计算机视觉（CV） | 图像分类（Image Classification） | [InceptionV3](https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/inceptionv3) | Supported | Doing | Doing | Doing | Doing | Doing -- Gitee From 1721105a1c1ebe7346e1b600997291a6a17891d5 Mon Sep 17 00:00:00 2001 From: donghufeng Date: Fri, 19 Mar 2021 14:37:57 +0800 Subject: [PATCH 13/79] images link --- .../advanced_use/parameterized_quantum_circuit.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tutorials/training/source_zh_cn/advanced_use/parameterized_quantum_circuit.ipynb b/tutorials/training/source_zh_cn/advanced_use/parameterized_quantum_circuit.ipynb index 80a5bcef33..8447dcdd75 100644 --- a/tutorials/training/source_zh_cn/advanced_use/parameterized_quantum_circuit.ipynb +++ b/tutorials/training/source_zh_cn/advanced_use/parameterized_quantum_circuit.ipynb @@ -297,7 +297,7 @@ "\n", "下面我们搭建如下的量子神经网络，该量子神经网络的编码部分由两个$\\text{RY}$门构成，而Ansatz线路由一个$\\text{CNOT}$门和两个$\\text{RX}$门构成，待测量物理量是作用在1号比特上的$\\text{Z}$算符。\n", "\n", - "![simple_qnn](https://gitee.com/mindspore/docs/raw/master/tutorials/training/source_zh_cn/advanced_use/images/simple_qnn.png)\n" + "![simple qnn](https://gitee.com/mindspore/docs/raw/master/tutorials/training/source_zh_cn/advanced_use/images/simple_qnn.png)\n" ] }, { -- Gitee From 8c3849b86a9144af7c0828f39d0d41958028fce9 Mon Sep 17 00:00:00 2001 From: jiangshuqiang Date: Fri, 12 Mar 2021 17:02:30 +0800 Subject: [PATCH 14/79] add dump tutorial --- .../source_zh_cn/data_pipeline.rst | 3 +- docs/programming_guide/source_zh_cn/dump.md | 464 ++++++++++++++++++ 2 files changed, 466 insertions(+), 1 deletion(-) create mode 100644 docs/programming_guide/source_zh_cn/dump.md diff --git a/docs/programming_guide/source_zh_cn/data_pipeline.rst b/docs/programming_guide/source_zh_cn/data_pipeline.rst index 8bc54aba6f..b1c23825aa 100644 --- a/docs/programming_guide/source_zh_cn/data_pipeline.rst +++ b/docs/programming_guide/source_zh_cn/data_pipeline.rst @@ -11,4 +11,5 @@ tokenizer dataset_conversion auto_augmentation - cache \ No newline at end of file + cache + dump_tutorial diff --git a/docs/programming_guide/source_zh_cn/dump.md b/docs/programming_guide/source_zh_cn/dump.md new file mode 100644 index 0000000000..200776d37d --- /dev/null +++ b/docs/programming_guide/source_zh_cn/dump.md @@ -0,0 +1,464 @@ +# 基于Dump功能对网络数据进行分析 + +`Linux` `Ascend` `GPU` `模型调优` `中级` `高级` + + + +- [基于Dump功能对网络数据进行分析](#基于dump功能对网络数据进行分析对比) + - [概述](#概述) + - [使用场景](#使用场景) + - [整体流程](#整体流程) + - [ANF-IR介绍](#ANF-IR介绍) + - [IR文件获取](#IR文件获取) + - [使用IR文件进行调试](#使用IR文件进行调试) + - [Dump功能介绍](#dump功能介绍) + - [Dump模式](#dump模式) + - [同步Dump](#同步dump) + - [同步Dump操作步骤](#同步dump操作步骤) + - [同步Dump数据对象](#dump数据对象) + - [同步Dump数据格式介绍](#同步dump数据格式介绍) + - [同步Dump数据分析样例](#同步dump数据分析样例) + - [异步Dump](#异步dump) + - [异步Dump操作步骤](#异步dump操作步骤) + - [异步Dump数据对象](#dump数据对象) + - [异步Dump数据格式介绍](#异步dump数据格式介绍) + - [异步Dump数据格式样例](#异步dump数据格式样例) + + + +   + +## 概述 + +为了对训练过程进行分析，用户需要感知训练过程中算子的输入和输出数据。 + +- 对于动态图模式，MindSpore提供了Python原生执行能力，用户可以在网络脚本运行过程中查看记录相应的输入输出，详情见[使用PyNative模式调试](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/debug_in_pynative_mode.html) 。 + +- 对于静态图模式，MindSpore提供了Dump功能，用来将模型训练中的图以及算子的输入输出数据保存到磁盘文件。 + +本文针对静态图模式，介绍如何基于Dump功能对网络数据进行分析对比。 + +### 使用场景 + +1. 静态图算子结果分析。 + + 通过Dump功能获得的IR图可以了解脚本代码与执行算子的映射关系（详情见[使用IR文件进行调试](#使用ir文件进行调试)）。结合执行算子的输入和输出数据，可以分析训练过程中可能存在的溢出、梯度爆炸与消失等问题，反向跟踪到脚本中可能存在问题的代码。 + +2. 特征图分析。 + + 通过获取图层的输出数据，分析特征图的信息。 + +3. 模型迁移。 + + 在将模型从第三方框架（TensorFlow、PyTorch）迁移到MindSpore的场景中，通过比对相同位置算子的输出数据，分析第三方框架和MindSpore对于同一模型的训练结果是否足够接近，来定位模型的精度问题。 + +## 整体流程 + +1. 从脚本找到对应的算子 + + 首先利用Dump功能获取相关的IR图文件，参考[IR文件获取](#ir文件获取)。然后通过图文件找到脚本中代码对应的算子，参考[使用IR文件进行调试](#使用ir文件进行调试)。 + +2. 从算子到Dump数据 + + 在了解脚本和算子的映射关系后，可以确定想要分析的算子名称，从而找到算子对应的dump文件，参考[同步Dump数据对象](#同步dump数据对象)和[异步Dump数据对象](#异步dump数据对象)。 + +3. 分析Dump数据 + + 通过解析Dump数据，可以与其他第三方框架进行对比。同步Dump数据格式参考[同步Dump数据格式介绍](#同步dump数据格式介绍)，异步Dump数据格式参考[异步Dump数据格式介绍](#异步dump数据格式介绍)。 + +## ANF-IR介绍 + +中间表示（IR）是程序编译过程中介于源语言和目标语言之间的程序表示，以方便编译器进行程序分析和优化，因此IR的设计需要考虑从源语言到目标语言的转换难度，同时考虑程序分析和优化的易用性和性能。 + +MindIR是一种基于图表示的函数式IR，其最核心的目的是服务于自动微分变换。自动微分采用的是基于函数式编程框架的变换方法，因此IR采用了接近于ANF函数式的语义。 + +关于ANF-IR的具体介绍，可以参考[MindSpore IR 文法定义](https://www.mindspore.cn/doc/note/zh-CN/master/design/mindspore/mindir.html#id2) 。 + +### IR文件获取 + +使用Dump功能将自动生成最终执行图的IR文件，Dump功能的配置见[同步Dump操作步骤](#同步dump操作步骤)和[异步Dump操作步骤](#异步dump操作步骤)，最终执行图IR文件命名和目录结构见[同步Dump数据对象](#同步dump数据对象)和[异步Dump数据对象](#异步dump数据对象)。 + +也可以在运行MindSpore脚本时，配置`context.set_context(save_graphs=True, save_graphs_path=“xxx”)`，会在指定路径"xxx"下（默认为脚本执行目录）保存图编译过程中生成的一些中间文件（IR文件），通过这些IR文件可以查看分析整个计算图的变换优化过程。 `set_context`的详情可参考[mindspore.context API](https://www.mindspore.cn/doc/api_python/zh-CN/master/mindspore/mindspore.context.html#mindspore.context.set_context) 。 + +IR文件可以用`vi`命令查看。IR文件中包含了算子全名，和算子在计算图中输入和输出的依赖，也包含从算子到相应脚本代码的Trace信息。 + +### 使用IR文件进行调试 + +对于Ascend场景，在通过Dump功能将脚本对应的图保存到磁盘上后，会产生最终执行图`ms_output_trace_code_graph_{graph_id}.ir`。该文件中保存了对应的图中每个算子的堆栈信息，记录了算子对应的生成脚本 。 + +以Alexnet脚本为例： + +```python +import mindspore.nn as nn +import mindspore.ops as ops + + +def conv(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode="valid", has_bias=True): + return nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, padding=padding, + has_bias=has_bias, pad_mode=pad_mode) + + +def fc_with_initialize(input_channels, out_channels, has_bias=True): + return nn.Dense(input_channels, out_channels, has_bias=has_bias) + + +class AlexNet(nn.Cell): + """ + Alexnet + """ + def __init__(self, num_classes=10, channel=3, phase='train', include_top=True): + super(AlexNet, self).__init__() + self.conv1 = conv(channel, 64, 11, stride=4, pad_mode="same", has_bias=True) + self.conv2 = conv(64, 128, 5, pad_mode="same", has_bias=True) + self.conv3 = conv(128, 192, 3, pad_mode="same", has_bias=True) + self.conv4 = conv(192, 256, 3, pad_mode="same", has_bias=True) + self.conv5 = conv(256, 256, 3, pad_mode="same", has_bias=True) + self.relu = ops.ReLU() + self.max_pool2d = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode="valid") + self.include_top = include_top + if self.include_top: + dropout_ratio = 0.65 + if phase == 'test': + dropout_ratio = 1.0 + self.flatten = nn.Flatten() + self.fc1 = fc_with_initialize(6 * 6 * 256, 4096) + self.fc2 = fc_with_initialize(4096, 4096) + self.fc3 = fc_with_initialize(4096, num_classes) + self.dropout = nn.Dropout(dropout_ratio) + + def construct(self, x): + """define network""" + 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.conv3(x) + x = self.relu(x) + x = self.conv4(x) + x = self.relu(x) + x = self.conv5(x) + x = self.relu(x) + x = self.max_pool2d(x) + if not self.include_top: + return x + x = self.flatten(x) + x = self.fc1(x) + x = self.relu(x) + x = self.dropout(x) + x = self.fc2(x) + x = self.relu(x) + x = self.dropout(x) + x = self.fc3(x) + return x +``` + +若要定位第58行代码`x = self.conv3(x)`的问题，可以在该脚本生成的`ms_output_trace_code_graph_{graph_id}.ir`文件中搜索该行代码，可以找到多个相关算子。如[同步Dump数据格式介绍](#同步dump数据格式介绍)所示，`Default/network-WithLossCell/_backbone-AlexNet/conv3-Conv2d/Conv2D-op107`就是其中之一的算子。 + +后续可以参考[同步Dump数据对象](#同步dump数据对象)，找到算子对应的dump文件。 + +## Dump功能介绍 + +### Dump模式 + +MindSpore提供了同步Dump与异步Dump两种模式。不同模式所需要的配置文件和dump出来的数据格式不同。 + +- 同步模式较异步模式会占用更多内存，但易用性更好。 + +- 一般对于中小型网络（如ResNet）等，推荐优先使用同步Dump模式。如果因为模型过大导致需要的内存超过系统限制，再使用异步Dump。 + +- 同步Dump目前支持Ascend和GPU，暂不支持CPU。 + +- 异步Dump目前仅支持Ascend。 + +### 同步Dump + +同步Dump的机制是在网络训练过程中每个step执行结束后， Host侧发起Dump动作，从Device上拷贝算子地址里面的数据到Host，并保存文件。同步Dump会默认关闭算子间的内存复用，避免读到脏数据。 + +#### 同步Dump操作步骤 + +1. 创建json格式的配置文件 + + 创建一个json格式的文件作为Dump的配置文件，如`data_dump.json`。 + 配置文件的内容规范介绍详见[同步Dump功能介绍](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/custom_debugging_info.html#id4) 。 + + 若配置文件中`trans_flag`为`True`，则数据会以Host侧的4D格式（NCHW）格式保存，若为`False`，则保留Device侧的数据格式。 + 若需要Dump全量或部分算子，则可以详见参考配置文件中的[dump_mode](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/custom_debugging_info.html#id4) 介绍。 + +2. 设置Dump环境变量 + + ```bash + export MINDSPORE_DUMP_CONFIG=${xxx} + ``` + + 其中"xxx"为配置文件的绝对路径，如： + + ```bash + export MINDSPORE_DUMP_CONFIG=/path/to/data_dump.json + ``` + +3. 启动训练 + + 训练启动后，若正确配置了`MINDSPORE_DUMP_CONFIG`环境变量，则会读取配置文件的内容，并按照Dump配置中指定的路径保存算子数据。 + 同步模式下，如果要Dump数据，必须采用非数据下沉模式（设置`model.train`或`DatasetHelper`中的`dataset_sink_mode`参数为`False`），以保证可以获取每个step的Dump数据。 + 若脚本中都不调用`model.train`或`DatasetHelper`，则默认为非数据下沉模式。使用Dump功能将自动生成最终执行图的IR文件。 + +### 同步Dump数据对象 + +同步Dump数据对象目录结构： + +```text +{path}/ + |-- {net_name}/ + |-- {device_id}/ + |-- iteration_{iteration}/ + -- {op_name}_{input_output_index}_{shape}_{data_type}_{format}.bin + … + |-- graphs/ + ms_output_trace_code_graph_{graph_id}.pb + ms_output_trace_code_graph_{graph_id}.ir + |-- execution_order/ + ms_execution_order_graph_{graph_id}.csv + + |-- .metadata/ + data_dump.json +``` + +- `path`：`data_dump.json`文件中设置的绝对路径。 +- `net_name`：`data_dump.json`文件中设置的网络名称。 +- `device_id`：训练的卡号。 +- `graph_id`：训练的图标号。 +- `iteration`：训练的轮次。 +- `operator_name`：算子名称。 +- `input_output_index` ：输入或输出标号，例如`output_0`表示该文件是该算子的第1个输出Tensor的数据。 +- `shape`: 张量维度信息。 +- `data_type`: 数据类型。 +- `format`: 数据格式。 + +Dump功能保存数据的对象就是最终执行图以及图中算子的输入和输出数据。 + +#### 同步Dump数据格式介绍 + +同步Dump生成的数据文件是后缀名为`.bin`的二进制文件，文件命名格式为： + +```text +{operator_name}_{input_output_index}_{shape}_{data_type}_{format}.bin +``` + +根据文件名提供的`Tensor`信息，可以用`numpy.fromfile`读取数据，并还原原始数据的`data_type`和`shape`。 + +同步Dump生成的最终执行图文件后缀名分别为`.pb`和`.ir`，文件命名格式为： + +```text +ms_output_trace_code_graph_{graph_id}.pb +ms_output_trace_code_graph_{graph_id}.ir +``` + +其中以`.ir`为后缀的文件可以通过`vi`命令打开查看 + +同步Dump生成的节点执行序文件后缀名为`.csv`，文件命名格式为： + +```text +ms_execution_order_graph_{graph_id}.csv +``` + +`.metadata`记录了训练的原信息，其中`data_dump.json`保存了用户设置的dump配置。 + +#### 同步Dump数据分析样例 + +以[alexnet脚本为例](https://gitee.com/mindspore/mindspore/blob/master/model_zoo/official/cv/alexnet/src/alexnet.py) ，如果用户想查看脚本中第58行的代码： + +```python +x = self.conv3(x) +``` + +可以从最终执行图中查找到该行代码所对应的多个算子，如下所示： + +```text + %24(equivoutput) = Conv2D(%23, %21) {instance name: conv2d} primitive_attrs: {compile_info: , pri_format: NC1HWC0, stride: (1, 1, 1, 1), pad: (0, 0, 0, 0), pad_mod: same, out_channel: +192, mode: 1, dilation: (1, 1, 1, 1), output_names: [output], group: 1, format: NCHW, offset_a: 0, kernel_size: (3, 3), groups: 1, input_names: [x, w], pad_list: (1, 1, 1, 1), +IsFeatureMapOutput: true, IsFeatureMapInputList: (0)} + : (, ) -> () + : (, ) -> () + : (Default/network-WithLossCell/_backbone-AlexNet/conv3-Conv2d/Conv2D-op107) + ... + # In file {Absolute path of model_zoo}/official/cv/alexnet/src/alexnet.py(58)/ x = self.conv3(x)/ + ... + %25(equivoutput) = BiasAdd(%24, %22) {instance name: bias_add} primitive_attrs: {output_used_num: (1), input_names: [x, b], format: NCHW, compile_info: , output_names: [output], +IsFeatureMapOutput: true, IsFeatureMapInputList: (0), pri_format: NC1HWC0} + : () -> () -> () + : () -> () -> () + : (Default/network-WithLossCell/_backbone-AlexNet/conv3-Conv2d/BiasAdd-op105) + ... + # In file {Absolute path of model_zoo}/official/cv/alexnet/src/alexnet.py(58)/ x = self.conv3(x)/ + ... +``` + +最终执行图中各行所表示的含义如下： + +- 算子在Host侧（第一行）和Device侧（第二行，有些算子可能不存在）的输入输出情况。从执行图可知，该算子有两个输入（箭头左侧），一个输出（箭头右侧）。 + +```text + : (, ) -> () + : (, ) -> () +``` + +- 算子名称。从执行图可知，该算子在最终执行图中的完整名称为`Default/network-WithLossCell/_backbone-AlexNet/conv3-Conv2d/Conv2D-op107`。 + +```text + : (Default/network-WithLossCell/_backbone-AlexNet/conv3-Conv2d/Conv2D-op107) +``` + +- 算子对应的训练脚本代码。通过搜索要查询的训练脚本代码，可以找到多个匹配的算子。 + +```text + # In file {Absolute path of model_zoo}/official/cv/alexnet/src/alexnet.py(58)/ x = self.conv3(x)/ +``` + +通过算子名称和输入输出信息，可以查找到唯一对应的Tensor数据文件。比如，若要查看Conv2D-op107算子的第1个输出数据对应的Dump文件，可获取以下信息： + +- `operator_name`：`Default--network-WithLossCell--_backbone-AlexNet--conv3-Conv2d--Conv2D-op107`。基于图中序号2声明的算子名称，将其中的`/`替换为`--`可得。 + +- `input_output_index` ：`output_0`表示该文件是该算子的第1个输出Tensor的数据。 + +在Dump目录下搜索到相应的文件名： +`Default--network-WithLossCell--_backbone-AlexNet--conv3-Conv2d--Conv2D-op107_output_0_shape_32_12_13_13_16_Float16_NC1HWC0.bin`。 +从文件名中可以得知以下信息： + +- `shape`: 张量维度是`32_12_13_13_16`。 + +- `data_type`: 数据类型为`Float16`。 + +- `format`: 数据格式为`NC1HWC0`（可通过Dump配置文件修改要保存的数据格式）。 + +还原数据的时候，首先通过执行： + +```python +import numpy +numpy.fromfile("Default--network-WithLossCell--_backbone-AlexNet--conv3-Conv2d--Conv2D-op107_output_0_shape_32_12_13_13_16_Float16_NC1HWC0.bin", numpy.float16) +``` + +生成一维array数据，再通过执行： + +```python +import numpy +numpy.reshape(array, (32,12,13,13,16)) +``` + +还原到原始shape数据。 + +### 异步Dump + +大型网络（如Bert Large）使用同步Dump时会导致内存溢出，MindSpore通过异步Dump提供了大型网络的调试能力。 + +异步Dump是专门针对Ascend整图下沉而开发的功能，可以一边执行算子一边dump数据，一个算子执行结束后立即dump数据，因此开启内存复用也可以生成正确的数据，但是相应的网络训练的速度会较慢。 + +#### 异步Dump操作步骤 + +- 异步Dump的操作步骤与同步Dump的操作步骤一致，只有配置文件的内容和数据解析方式不同。 异步Dump的配置文件内容规范详见[异步Dump功能介绍](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/custom_debugging_info.html#id4) + +- 若需要dump全量或部分算子，则可以详见参考配置文件中的[dump_mode](https://www.mindspore.cn/tutorial/training/zh-CN/master/advanced_use/custom_debugging_info.html#id5) 介绍。 + +- 若开启数据下沉功能（设置`model.train`或`DatasetHelper`中的`dataset_sink_mode`参数为`True`），只能dump出配置文件里指定的一个step的数据（此时`iteration 0`表示第0个step），并保存到指定目录下。 + +- 若不开启数据下沉功能（设置`model.train`或`DatasetHelper`中的`dataset_sink_mode`参数为`False`），配置文档里`iteration`必须指定为0，所有step的数据都保存在一个目录中，无法支持多step的数据管理。此时建议只执行一次step的数据Dump（可以通过修改脚本只训练一个step）。 + +- 使用Dump功能将自动生成最终执行图的IR文件。 + +### 异步Dump数据对象 + +同步Dump数据对象目录结构： + +```text +{path}/ + |-- {device_id}/ + |-- {new_name}_graph_{graph_id}/ + |-- {graph_id}/ + |-- {iteration}/ + |-- {op_type}.{op_name}.{task_id}.{timestamp} + … + |-- graphs/ + ms_output_trace_code_graph_{graph_id}.pb + ms_output_trace_code_graph_{graph_id}.ir + |-- execution_order/ + ms_execution_order_graph_{graph_id}.csv + + |-- .metadata/ + data_dump.json +``` + +- `path`：`data_dump.json`文件中设置的绝对路径。 +- `net_name`：`data_dump.json`文件中设置的网络名称。 +- `device_id`：训练的卡号。 +- `graph_id`：训练的图标号。 +- `iteration`：训练的轮次。 +- `op_type`：算子类型。 +- `op_name`：算子名称。 +- `taskid`：任务标号。 +- `timestamp`：时间戳。 + +Dump功能保存数据的对象就是最终执行图以及图中算子的输入和输出数据。 + +#### 异步Dump数据格式介绍 + +异步Dump生成的原始数据文件是protobuf格式的文件，需要用到海思Run包中自带的数据解析工具进行解析，详见[使用文档](https://support.huaweicloud.com/tg-Inference-cann/atlasaccuracy_16_0014.html) 。 + +数据在Device侧的格式可能和Host侧计算图中的定义不同，异步Dump的数据格式为Device侧格式，如果想要转为Host侧格式，可以参考[使用文档](https://support.huaweicloud.com/tg-Inference-cann/atlasaccuracy_16_0013.html) 。 + +异步Dump生成的数据文件命名规则如下： + +```text +{op_type}.{op_name}.{taskid}.{timestamp} +``` + +如果`op_type`和`op_name`中出现了“.”、“/”、“\”、空格时，会转换为下划线表示。 + +异步Dump生成的最终执行图文件和节点执行序文件命名规则与同步Dump相同 + +#### 异步Dump数据格式样例 + +通过异步Dump的功能，获取到算子的异步Dump的文件，如： + +```text +dump_file: "BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491" +``` + +执行： + +```text +python3.7.5 msaccucmp.pyc convert -d BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491 -out ./output -f NCHW -t npy +``` + +则可以在`./output`下生成该算子的所有输入输出数据。每个数据以`.npy`后缀的文件保存，数据格式为`NCHW`。 +在生成结果如下： + +```text +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.0.30x1024x17x17.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.1.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.2.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.3.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.4.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.5.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.6.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.output.0.30x1024x17x17.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.output.1.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.output.2.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.output.3.1x1024x1x1.npy +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.output.4.1x1024x1x1.npy +``` + +在文件名的末尾可以看到该文件是算子的第几个输入或输出，以及数据的维度信息。例如，通过第一个文件名 + +```text +BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.0.30x1024x17x17.npy +``` + +可知该文件是算子的第0个输入，数据的维度信息是`30x1024x17x17`。 + +通过`numpy.load("file_name")`可以读取到对应数据。例： + +```python +import numpy +numpy.load("BNTrainingUpdate.Default_network-YoloWithLossCell_yolo_network-YOLOV3DarkNet53_feature_map-YOLOv3_backblock0-YoloBlock_conv3-SequentialCell_1-BatchNorm2d_BNTrainingUpdate-op5489.137.1608983934774491.input.0.30x1024x17x17.npy") +``` \ No newline at end of file -- Gitee From 7a48f308b5ee0afbd18fea710642bef5b04b51d6 Mon Sep 17 00:00:00 2001 From: yingchen Date: Fri, 19 Mar 2021 14:57:51 +0800 Subject: [PATCH 15/79] fix bugs --- docs/programming_guide/source_zh_cn/conf.py | 5 ----- tutorials/lite/source_zh_cn/index.rst | 2 +- 2 files changed, 1 insertion(+), 6 deletions(-) diff --git a/docs/programming_guide/source_zh_cn/conf.py b/docs/programming_guide/source_zh_cn/conf.py index 646636b166..adbf28ca53 100644 --- a/docs/programming_guide/source_zh_cn/conf.py +++ b/docs/programming_guide/source_zh_cn/conf.py @@ -73,11 +73,6 @@ html_search_options = {'dict': '../../resource/jieba.txt'} html_static_path = ['_static'] -def setup(app): - app.add_stylesheet('css/bootstrap.min.css') - app.add_stylesheet('css/training.css') - app.add_javascript('js/training.js') - # Remove extra outputs for nbsphinx extension. nbsphinx_source_re = re.compile(r"(app\.connect\('html-collect-pages', html_collect_pages\))") nbsphinx_math_re = re.compile(r"(\S.*$)") diff --git a/tutorials/lite/source_zh_cn/index.rst b/tutorials/lite/source_zh_cn/index.rst index a82e8a3dc8..e84b42a3f2 100644 --- a/tutorials/lite/source_zh_cn/index.rst +++ b/tutorials/lite/source_zh_cn/index.rst @@ -177,7 +177,7 @@