diff --git a/api/source_en/api/python/mindinsight/mindinsight.lineagemgr.rst b/api/source_en/api/python/mindinsight/mindinsight.lineagemgr.rst
deleted file mode 100644
index f63acde3548d15bbc747e99164a5a9760a4a84d5..0000000000000000000000000000000000000000
--- a/api/source_en/api/python/mindinsight/mindinsight.lineagemgr.rst
+++ /dev/null
@@ -1,5 +0,0 @@
-mindinsight.lineagemgr
-======================
-
-.. automodule:: mindinsight.lineagemgr
-    :members:
\ No newline at end of file
diff --git a/api/source_en/conf.py b/api/source_en/conf.py
index f08d1d521a703cf90caccecbbb903e8209651986..dc2ef84ebec642d4ab9fdfa59e7bd255494eed5b 100644
--- a/api/source_en/conf.py
+++ b/api/source_en/conf.py
@@ -16,8 +16,6 @@ import os
 # sys.path.insert(0, os.path.abspath('.'))
 
 import mindspore
-# If you don't want to generate MindInsight APIs, comment this line.
-import mindinsight
 # If you don't want to generate MindArmour APIs, comment this line.
 import mindarmour
 
diff --git a/api/source_en/index.rst b/api/source_en/index.rst
index c5053627a364b1da9f9ab49ed7f3eef9db16de68..36b995c3e84db9f0cbd7b4625d0c5c387ca4e468 100644
--- a/api/source_en/index.rst
+++ b/api/source_en/index.rst
@@ -33,12 +33,6 @@ MindSpore API
    api/python/mindspore/mindspore.mindrecord
    api/python/mindspore/mindspore.profiler
 
-.. toctree::
-   :maxdepth: 1
-   :caption: MindInsight Python API
-
-   api/python/mindinsight/mindinsight.lineagemgr
-
 .. toctree::
    :maxdepth: 1
    :caption: MindArmour Python API
diff --git a/api/source_zh_cn/api/python/mindinsight/mindinsight.lineagemgr.rst b/api/source_zh_cn/api/python/mindinsight/mindinsight.lineagemgr.rst
deleted file mode 100644
index f63acde3548d15bbc747e99164a5a9760a4a84d5..0000000000000000000000000000000000000000
--- a/api/source_zh_cn/api/python/mindinsight/mindinsight.lineagemgr.rst
+++ /dev/null
@@ -1,5 +0,0 @@
-mindinsight.lineagemgr
-======================
-
-.. automodule:: mindinsight.lineagemgr
-    :members:
\ No newline at end of file
diff --git a/api/source_zh_cn/conf.py b/api/source_zh_cn/conf.py
index 21de9d481a8ebf6d162e4c63d605dfd4aa42dbf5..474f58597111c2265fa45830835a325c6418b28e 100644
--- a/api/source_zh_cn/conf.py
+++ b/api/source_zh_cn/conf.py
@@ -16,8 +16,6 @@ import os
 # sys.path.insert(0, os.path.abspath('.'))
 
 import mindspore
-# If you don't want to generate MindInsight APIs, comment this line.
-import mindinsight
 # If you don't want to generate MindArmour APIs, comment this line.
 import mindarmour
 
diff --git a/api/source_zh_cn/index.rst b/api/source_zh_cn/index.rst
index 63b9597aef3b4cb840093dc03464ecf78b457685..d5014c4f390c8b3a1484ce59509ffb746e323547 100644
--- a/api/source_zh_cn/index.rst
+++ b/api/source_zh_cn/index.rst
@@ -39,12 +39,6 @@ MindSpore API
    api/python/mindspore/mindspore.mindrecord
    api/python/mindspore/mindspore.profiler
 
-.. toctree::
-   :maxdepth: 1
-   :caption: MindInsight Python API
-
-   api/python/mindinsight/mindinsight.lineagemgr
-
 .. toctree::
    :maxdepth: 1
    :caption: MindArmour Python API
diff --git a/docs/source_en/operator_list.md b/docs/source_en/operator_list.md
index 3a79b0a2b9e79d7375608e4ed9a421cf1360a1f4..43a3acbcb4c354e53e2d70eecd615417638922c7 100644
--- a/docs/source_en/operator_list.md
+++ b/docs/source_en/operator_list.md
@@ -67,7 +67,7 @@
 | [mindspore.nn.L1Loss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.L1Loss)                                                |Supported |Supported | Doing |loss/loss
 | [mindspore.nn.MSELoss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MSELoss)                                              |  Supported |Doing | Doing |loss/loss
 | [mindspore.nn.SmoothL1Loss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SmoothL1Loss)                                    |Supported |Doing | Doing |loss/loss
-| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits)  |  Supported |  Supported |   Doing |loss/loss
+| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits)  |  Supported |  Supported |   Supported |loss/loss
 | [mindspore.nn.SoftmaxCrossEntropyExpand](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyExpand)     |  Supported |Supported | Doing |loss/loss
 | [mindspore.nn.CosineEmbeddingLoss](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CosineEmbeddingLoss)                                                |Supported |Supported | Doing |loss/loss
 | [mindspore.nn.ProximalAdagrad](https://www.mindspore.cn/api/en/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ProximalAdagrad)                              | Supported | Doing | Doing |optim/ProximalAdagrad
diff --git a/docs/source_zh_cn/operator_list.md b/docs/source_zh_cn/operator_list.md
index db8e29e3935556c95e4aabc477cc297d2561c8d0..74b61374331a2e838b537b29203a81df4bab5039 100644
--- a/docs/source_zh_cn/operator_list.md
+++ b/docs/source_zh_cn/operator_list.md
@@ -67,7 +67,7 @@
 | [mindspore.nn.L1Loss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.L1Loss)                                                |Supported |Supported | Doing |loss/loss
 | [mindspore.nn.MSELoss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.MSELoss)                                              |  Supported |Doing | Doing |loss/loss
 | [mindspore.nn.SmoothL1Loss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SmoothL1Loss)                                    | Supported |Doing | Doing |loss/loss
-| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits)  |  Supported |  Supported |   Doing |loss/loss
+| [mindspore.nn.SoftmaxCrossEntropyWithLogits](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyWithLogits)  |  Supported |  Supported |   Supported |loss/loss
 | [mindspore.nn.SoftmaxCrossEntropyExpand](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.SoftmaxCrossEntropyExpand)          |  Supported |Supported | Doing |loss/loss
 | [mindspore.nn.CosineEmbeddingLoss](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.CosineEmbeddingLoss)                                                |Supported |Supported | Doing |loss/loss
 | [mindspore.nn.ProximalAdagrad](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.nn.html#mindspore.nn.ProximalAdagrad)                              |  Supported |Doing | Doing |optim/ProximalAdagrad
diff --git a/lite/tutorials/source_en/use/timeprofiler_tool.md b/lite/tutorials/source_en/use/timeprofiler_tool.md
index d7abe79fb75a951178dfb014b6ee76ee97813f36..b0e3d35860448974da085d8230d58654bf46868e 100644
--- a/lite/tutorials/source_en/use/timeprofiler_tool.md
+++ b/lite/tutorials/source_en/use/timeprofiler_tool.md
@@ -20,7 +20,7 @@ After model conversion and before inference, you can use the TimeProfiler tool t
 
 To use the TimeProfiler tool, you need to prepare the environment as follows:
 
-- Compilation: Install build dependencies and perform build. The code of the TimeProfiler tool is stored in the `mindspore/lite/tools/time_profile` directory of the MindSpore source code. For details about the build operations, see the [Environment Requirements](https://www.mindspore.cn/lite/tutorial/en/master/compile.html#environment-requirements) and [Compilation Example](https://www.mindspore.cn/lite/tutorial/en/master/compile.html#compilation-example) in the build document.
+- Compilation: Install build dependencies and perform build. The code of the TimeProfiler tool is stored in the `mindspore/lite/tools/time_profile` directory of the MindSpore source code. For details about the build operations, see the [Environment Requirements](https://www.mindspore.cn/lite/tutorial/en/master/build.html#environment-requirements) and [Compilation Example](https://www.mindspore.cn/lite/tutorial/en/master/build.html#compilation-example) in the build document.
 
 - Run: Obtain the `timeprofile` tool and configure environment variables by referring to [Output Description](https://www.mindspore.cn/lite/tutorial/en/master/build.html#output-description) in the build document.
 
diff --git a/tools/link_detection/README_CN.md b/tools/link_detection/README_CN.md
index 58ab4f8d238ee6be7c420320d17c41a82ab100f1..442726a409139e21f99d432923946255903b9213 100644
--- a/tools/link_detection/README_CN.md
+++ b/tools/link_detection/README_CN.md
@@ -21,7 +21,7 @@
    cd tools/link_detection
    pip install requests
    ```
-3. 在`link_check`目录下执行如下命令，在输入需要检测目录的绝对路径后，开始进行检测，完成后会在当前目录下新建`404.txt`、`exception.txt`、`slow.txt`三个文件。
+3. 在`link_detection`目录下执行如下命令，在输入需要检测目录的绝对路径后，开始进行检测，完成后会在当前目录下新建`404.txt`、`exception.txt`、`slow.txt`三个文件。
    ```
    python link_detection.py
    ```
diff --git a/tools/pic_detection/README_CN.md b/tools/pic_detection/README_CN.md
new file mode 100644
index 0000000000000000000000000000000000000000..c217d51929f0d07908d62695626ec68a2b465d77
--- /dev/null
+++ b/tools/pic_detection/README_CN.md
@@ -0,0 +1,27 @@
+# 图片检查工具
+
+## 简介
+
+此工具可以检查用户指定目录里所有图片的使用情况，会检查出没有使用的图片，并且将没有使用的图片删除。
+
+
+## 使用说明
+
+该工具所依赖的操作系统为Windows操作系统，执行环境为Python环境，具体使用步骤如下所示：
+
+1. 打开Git Bash，下载MindSpore Docs仓代码。
+   ```
+   git clone https://gitee.com/mindspore/docs.git
+   ```
+2. 进入`tools/pic_detection`目录。
+   ```
+   cd tools/pic_detection
+   ```
+3. 在`pic_detection`目录下执行如下命令，在输入需要检测目录的绝对路径后，开始进行检测，最后将没有使用的图片删除。
+   ```
+   python pic_detection.py
+   ```
+   > 检测目录的绝对路径全使用英文，并且使用Linux的绝对路径方式，例如：`/d/master/docs`。 
+   
+
+
diff --git a/tools/pic_detection/pic_detection.py b/tools/pic_detection/pic_detection.py
new file mode 100644
index 0000000000000000000000000000000000000000..a69cd53134a2d62380208a05284407a346d194d7
--- /dev/null
+++ b/tools/pic_detection/pic_detection.py
@@ -0,0 +1,88 @@
+import subprocess
+import os
+
+def get_images_dierctory(check_path):
+    '''
+    get all images directory.
+    '''
+    cmd = 'find %s -type d -name images' %check_path
+    res = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+    dir_list = res.stdout.read().decode('utf-8').split('\n')
+    del dir_list[-1]
+    return dir_list
+
+def get_all_pic(dir_list):
+    '''
+    get all the images in the images directory.
+    '''
+    for dir in dir_list:
+        res = subprocess.Popen('ls %s'%dir, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        pic_list = res.stdout.read().decode('utf-8').split('\n')
+        del pic_list[-1]
+        for i in pic_list:
+            pic_all.add(i)
+
+def get_use_pic(check_path):
+    '''
+    get all the useful pictures.
+    '''
+    cmd1 = 'find %s -type f -name "*.md"' %check_path
+    cmd2 = 'find %s -type f -name "*.ipynb"' %check_path
+    cmd3 = [cmd1, cmd2]
+    for i in cmd3:
+        res = subprocess.Popen(i, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        file_list = res.stdout.read().decode('utf-8').split('\n')
+        del file_list[-1]
+        for j in file_list:
+            j = j.split('/', 1)[1].replace('/', ':/', 1)
+            with open(j, 'r', encoding='utf-8') as f:
+                data = f.read()
+                for k in pic_all:
+                    if k in data:
+                        use_pic.add(k)
+
+def get_use_eddx():
+    '''
+    get all the useful eddx files.
+    '''
+    for i in filter_pic:
+        if i.endswith('eddx'):
+            if i.split('.')[0] in ' '.join(use_pic):
+                use_eddx.add(i)
+
+def get_useless_pic_path(check_path):
+    '''
+    get the absolute path of all useless pictures.
+    '''
+    for i in useless_pic:
+        cmd = 'find %s -type f -name %s' %(check_path,i)
+        res = subprocess.Popen(cmd, shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        data = res.stdout.read().decode('utf-8').split('\n')
+        del data[-1]
+        for j in data:
+            path.append(j)
+
+def del_useless_pic():
+    '''
+    delete all useless pictures.
+    '''
+    for i in path:
+        os.system('rm -rf %s' %i)
+
+
+if __name__ == '__main__':
+    check_path = input('请输入您要检测的绝对路径：').strip()
+    pic_all = set()
+    use_pic = set()
+    use_eddx = set()
+    path = []
+    dir_list = get_images_dierctory(check_path)
+    get_all_pic(dir_list)
+    get_use_pic(check_path)
+    filter_pic = pic_all.difference(use_pic)
+    get_use_eddx()
+    useless_pic = filter_pic.difference(use_eddx)
+    get_useless_pic_path(check_path)
+    print('没有用的照片：', path)
+    del_useless_pic()
+    print('删除成功')
diff --git a/tutorials/notebook/computer_vision_application.ipynb b/tutorials/notebook/computer_vision_application.ipynb
index f6a65a867c7f1be61b2a417ff1f4273718940790..6d8dfd2d87f44f46f8ca5573d295735a4ff30d91 100644
--- a/tutorials/notebook/computer_vision_application.ipynb
+++ b/tutorials/notebook/computer_vision_application.ipynb
@@ -71,7 +71,7 @@
    "metadata": {},
    "source": [
     "本次面向Ascend 910 AI处理器硬件平台,将卷积神经网络ResNet加入到案例中，你可以在这里下载完整的样例代码案例作为基础用例：\n",
-    "https://gitee.com/mindspore/docs/blob/master/tutorials/tutorial_code/resnet"
+    "https://gitee.com/mindspore/docs/tree/master/tutorials/tutorial_code/resnet"
    ]
   },
   {
@@ -345,7 +345,8 @@
    "outputs": [],
    "source": [
     "from mindspore.communication.management import init\n",
-    "from mindspore.train.model import Model, ParallelMode\n",
+    "from mindspore.train.model import Model\n",
+    "from mindspore.context import ParallelMode\n",
     "from resnet import resnet50\n",
     "from mindspore.parallel._auto_parallel_context import auto_parallel_context\n",
     "\n",
@@ -387,7 +388,7 @@
     "from mindspore.nn.optim.momentum import Momentum\n",
     "from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits\n",
     "\n",
-    "ls = SoftmaxCrossEntropyWithLogits(sparse=True, is_grad=False, reduction=\"mean\")\n",
+    "ls = SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01, 0.9)"
    ]
   },
diff --git a/tutorials/notebook/convert_dataset_to_mindspore_data_format/convert_dataset_to_mindspore_data_format.ipynb b/tutorials/notebook/convert_dataset_to_mindspore_data_format/convert_dataset_to_mindspore_data_format.ipynb
index 60f0ffe0c6ad6562918a6295e1e0f7293abc0cfb..f34bc0c817f399bc5bdac90a497910d626d24d5f 100644
--- a/tutorials/notebook/convert_dataset_to_mindspore_data_format/convert_dataset_to_mindspore_data_format.ipynb
+++ b/tutorials/notebook/convert_dataset_to_mindspore_data_format/convert_dataset_to_mindspore_data_format.ipynb
@@ -281,7 +281,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "- 本例中需要的数据位置在https://gitee.com/mindspore/docs/tree/master/tutorials/notebook/convert_dataset_to_mindspore_data_format/csv_data/data.csv\n",
+    "- 本例中需要的数据位置在https://gitee.com/mindspore/docs/blob/master/tutorials/notebook/convert_dataset_to_mindspore_data_format/csv_data/data.csv\n",
     "中，使用过程中可以在此路径下找到文件并下载，并且保存在`jupyter工作目录/dataset/`下，如图所示："
    ]
   },
@@ -838,7 +838,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "3. 准备需要写入的数据，按照用户定义的Schema形式，准备需要写入的样本列表，本例中需要的数据位置在https://gitee.com/mindspore/docs/tree/master/tutorials/notebook/convert_dataset_to_mindspore_data_format/images/transform.jpg\n",
+    "3. 准备需要写入的数据，按照用户定义的Schema形式，准备需要写入的样本列表，本例中需要的数据位置在https://gitee.com/mindspore/docs/blob/master/tutorials/notebook/convert_dataset_to_mindspore_data_format/images/transform.jpg\n",
     "中，使用过程中可以在此路径下找到图片并下载，并且保存在`jupyter工作目录/dataset/`下。"
    ]
   },
diff --git a/tutorials/notebook/customized_debugging_information.ipynb b/tutorials/notebook/customized_debugging_information.ipynb
index 7ef6762a17ec7e4a8d8ce8389d6bed61fea52422..44be7bd3a753b3c00b1851729badec85be8b4584 100644
--- a/tutorials/notebook/customized_debugging_information.ipynb
+++ b/tutorials/notebook/customized_debugging_information.ipynb
@@ -386,7 +386,7 @@
     "train_data_path = \"./MNIST_Data/train\"\n",
     "eval_data_path = \"./MNIST_Data/train\"\n",
     "\n",
-    "net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')\n",
+    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "repeat_size = epoch_size\n",
     "network = LeNet5()\n",
     "\n",
diff --git a/tutorials/notebook/debugging_in_pynative_mode.ipynb b/tutorials/notebook/debugging_in_pynative_mode.ipynb
index b068dddd05fc8bde544cf34f234b405b02db40dd..ce3d50557b55592afefaca452b1ecbd56d45521a 100644
--- a/tutorials/notebook/debugging_in_pynative_mode.ipynb
+++ b/tutorials/notebook/debugging_in_pynative_mode.ipynb
@@ -488,7 +488,7 @@
     "\n",
     "net = LeNet5()\n",
     "optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.1, 0.9)\n",
-    "criterion = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)\n",
+    "criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
     "net_with_criterion = WithLossCell(net, criterion)\n",
     "train_network = GradWrap(net_with_criterion)\n",
     "train_network.set_train()\n",
diff --git a/tutorials/notebook/mindinsight/calculate_and_datagraphic.ipynb b/tutorials/notebook/mindinsight/calculate_and_datagraphic.ipynb
index 2eb475d31541d52e7af5edc5c2b76a55cc3374b2..39bffb88e5b016f15bd05e5057c4450eaf9d103f 100644
--- a/tutorials/notebook/mindinsight/calculate_and_datagraphic.ipynb
+++ b/tutorials/notebook/mindinsight/calculate_and_datagraphic.ipynb
@@ -311,7 +311,7 @@
     "    ds_train = create_dataset(data_path=\"./MNIST_Data/train/\")\n",
     "\n",
     "    network = LeNet5()\n",
-    "    net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction=\"mean\")\n",
+    "    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "    net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)\n",
     "    time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
     "    model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()})\n",
diff --git a/tutorials/notebook/mindinsight/images/summary_list.png b/tutorials/notebook/mindinsight/images/summary_list.png
deleted file mode 100644
index 5b3f170433d0fee73d4d462efe6cfd6dfeb5a166..0000000000000000000000000000000000000000
Binary files a/tutorials/notebook/mindinsight/images/summary_list.png and /dev/null differ
diff --git a/tutorials/notebook/mindinsight/mindinsight_image_histogram_scalar_tensor.ipynb b/tutorials/notebook/mindinsight/mindinsight_image_histogram_scalar_tensor.ipynb
index 08a68bdb080a475a114bfbbc57f463113e64f289..082a64b00e3f4f48d27703742e137aa6f11e6d64 100644
--- a/tutorials/notebook/mindinsight/mindinsight_image_histogram_scalar_tensor.ipynb
+++ b/tutorials/notebook/mindinsight/mindinsight_image_histogram_scalar_tensor.ipynb
@@ -544,7 +544,7 @@
    "source": [
     "\n",
     "network = AlexNet(num_classes=10)\n",
-    "net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction=\"mean\")\n",
+    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "lr = Tensor(get_lr(0, 0.002, 10, ds_train.get_dataset_size()))\n",
     "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
     "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
@@ -777,7 +777,7 @@
     "\n",
     "lr = Tensor(get_lr(0, 0.002, 10, ds_train.get_dataset_size()))\n",
     "network = AlexNet(num_classes=10)\n",
-    "net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction=\"mean\")\n",
+    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
     "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
     "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
@@ -873,7 +873,7 @@
    "source": [
     "lr = Tensor(get_lr(0, 0.002, 1, ds_train.get_dataset_size()))\n",
     "network = AlexNet(num_classes=10)\n",
-    "net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction=\"mean\")\n",
+    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
     "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
     "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
@@ -1017,7 +1017,7 @@
     "\n",
     "lr = Tensor(get_lr(0, 0.002, 1, ds_train.get_dataset_size()))\n",
     "network = AlexNet(num_classes=10)\n",
-    "net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction=\"mean\")\n",
+    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
     "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
     "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
@@ -1153,7 +1153,7 @@
     "\n",
     "lr = Tensor(get_lr(0, 0.002, 1, ds_train.get_dataset_size()))\n",
     "network = AlexNet(num_classes=10)\n",
-    "net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction=\"mean\")\n",
+    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
     "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
     "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
diff --git a/tutorials/notebook/mindinsight/mindinsight_model_lineage_and_data_lineage.ipynb b/tutorials/notebook/mindinsight/mindinsight_model_lineage_and_data_lineage.ipynb
index 3a09e78dc423d7634c1f32c9ba7ff91109afb600..c55cbd60f470f84b998ca828d6ed39d2d87257cc 100644
--- a/tutorials/notebook/mindinsight/mindinsight_model_lineage_and_data_lineage.ipynb
+++ b/tutorials/notebook/mindinsight/mindinsight_model_lineage_and_data_lineage.ipynb
@@ -313,7 +313,7 @@
     "    epoch_size = 10\n",
     "    mnist_path = \"./MNIST_Data\"\n",
     "    \n",
-    "    net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')\n",
+    "    net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
     "    repeat_size = 1\n",
     "    # create the network\n",
     "    network = LeNet5()\n",
diff --git a/tutorials/notebook/mixed_precision.ipynb b/tutorials/notebook/mixed_precision.ipynb
index b57154f1e1a6bfb4cde295dbbe8a36c48cd1c006..1455e1710d0a441722c49bb762baf1e05049e3c3 100644
--- a/tutorials/notebook/mixed_precision.ipynb
+++ b/tutorials/notebook/mixed_precision.ipynb
@@ -859,7 +859,7 @@
     "    weight_decay = 1e-4\n",
     "    \n",
     "    # define loss, model\n",
-    "    loss = SoftmaxCrossEntropyWithLogits(sparse=True, is_grad=False, reduction='mean')\n",
+    "    loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
     "    opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr, momentum)\n",
     "    model = Model(net, loss_fn=loss, optimizer=opt, metrics={'acc'},amp_level=\"O2\")\n",
     "    \n",
@@ -952,7 +952,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "当然，如果你想参考单步训练或者手动设置混合精度训练，可以参考官网教程<https://www.mindspore.com/tutorial/zh-CN/master/advanced_use/mixed_precision.html>。"
+    "当然，如果你想参考单步训练或者手动设置混合精度训练，可以参考官网教程<https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/mixed_precision.html>。"
    ]
   },
   {
diff --git a/tutorials/notebook/model_security.ipynb b/tutorials/notebook/model_security.ipynb
index f1c00155f64a3c3bde554b7628e17e1fd94d0bc3..d958155df781b04021d7fa920f1c03b65b69f6a9 100644
--- a/tutorials/notebook/model_security.ipynb
+++ b/tutorials/notebook/model_security.ipynb
@@ -422,7 +422,7 @@
     "lr = 0.01\n",
     "momentum = 0.9\n",
     "network = LeNet5()\n",
-    "net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction=\"mean\")\n",
+    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
     "net_opt = nn.Momentum(network.trainable_params(), lr, momentum)\n",
     "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
     "config_ck = CheckpointConfig(save_checkpoint_steps=1875,\n",
@@ -752,7 +752,7 @@
     "from mindarmour.defenses import NaturalAdversarialDefense\n",
     "\n",
     "\n",
-    "loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=False)\n",
+    "loss = SoftmaxCrossEntropyWithLogits(sparse=False, reduction='mean')\n",
     "opt = nn.Momentum(net.trainable_params(), 0.01, 0.09)\n",
     "\n",
     "nad = NaturalAdversarialDefense(net, loss_fn=loss, optimizer=opt,\n",
diff --git a/tutorials/notebook/nlp_application.ipynb b/tutorials/notebook/nlp_application.ipynb
index 8920dfef4cd45971f0711cba8d898f1065df77ec..02cf130217ea5634fb6d87cc6059dc4c71809427 100644
--- a/tutorials/notebook/nlp_application.ipynb
+++ b/tutorials/notebook/nlp_application.ipynb
@@ -821,7 +821,7 @@
     "from mindspore import nn\n",
     "\n",
     "\n",
-    "loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)\n",
+    "loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
     "opt = nn.Momentum(network.trainable_params(), cfg.learning_rate, cfg.momentum)"
    ]
   },
diff --git a/tutorials/notebook/quick_start.ipynb b/tutorials/notebook/quick_start.ipynb
index c1b390cedfb72b09cc83cc6c5099035fcd070e28..b60f82f7846ee4075ff8d747cc2d2f7e29717e26 100644
--- a/tutorials/notebook/quick_start.ipynb
+++ b/tutorials/notebook/quick_start.ipynb
@@ -58,8 +58,8 @@
    "execution_count": 1,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:35.668048Z",
-     "start_time": "2020-09-01T09:38:35.658427Z"
+     "end_time": "2020-09-04T06:46:31.241068Z",
+     "start_time": "2020-09-04T06:46:31.232345Z"
     }
    },
    "outputs": [
@@ -100,8 +100,8 @@
    "execution_count": 2,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:35.686357Z",
-     "start_time": "2020-09-01T09:38:35.669064Z"
+     "end_time": "2020-09-04T06:46:31.263831Z",
+     "start_time": "2020-09-04T06:46:31.242077Z"
     }
    },
    "outputs": [
@@ -119,10 +119,12 @@
     "import gzip \n",
     "import os\n",
     "\n",
-    "def unzipfile(gzip_path):\n",
-    "    \"\"\"unzip dataset file\n",
+    "def unzip_file(gzip_path):\n",
+    "    \"\"\"\n",
+    "    unzip dataset file\n",
+    "    \n",
     "    Args:\n",
-    "        gzip_path: dataset file path\n",
+    "        gzip_path (str): dataset file path\n",
     "    \"\"\"\n",
     "    open_file = open(gzip_path.replace('.gz',''), 'wb')\n",
     "    gz_file = gzip.GzipFile(gzip_path)\n",
@@ -148,7 +150,7 @@
     "        file_name = os.path.join(train_path,url_parse.path.split('/')[-1])\n",
     "        if not os.path.exists(file_name.replace('.gz', '')):\n",
     "            file = urllib.request.urlretrieve(url, file_name)\n",
-    "            unzipfile(file_name)\n",
+    "            unzip_file(file_name)\n",
     "            os.remove(file_name)\n",
     "            \n",
     "    for url in test_url:\n",
@@ -157,7 +159,7 @@
     "        file_name = os.path.join(test_path,url_parse.path.split('/')[-1])\n",
     "        if not os.path.exists(file_name.replace('.gz', '')):\n",
     "            file = urllib.request.urlretrieve(url, file_name)\n",
-    "            unzipfile(file_name)\n",
+    "            unzip_file(file_name)\n",
     "            os.remove(file_name)\n",
     "\n",
     "download_dataset()"
@@ -203,8 +205,8 @@
    "execution_count": 3,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:37.018292Z",
-     "start_time": "2020-09-01T09:38:35.688435Z"
+     "end_time": "2020-09-04T06:46:32.448830Z",
+     "start_time": "2020-09-04T06:46:31.265357Z"
     }
    },
    "outputs": [
@@ -216,12 +218,12 @@
       "Number of pictures contained in the mnist_ds： 60000\n",
       "The item of mnist_ds: dict_keys(['image', 'label'])\n",
       "Tensor of image in item: (28, 28, 1)\n",
-      "The label of item: 9\n"
+      "The label of item: 5\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAEICAYAAACZA4KlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAANh0lEQVR4nO3df+xddX3H8edrWEpWMFIZUAFFGVvmFlfMd2iiMSxugrgE/ENiY5aamJVFWGbCEolbIllmZpapc3H+qINRFn9gpgRM2IQ1WxhuIX4hWIqoMFKltqOSyvgxKQXf++N7un358v3Ve8/90e/n+Uhu7rnn57snfd1z7vmc8/2kqpC09v3cpAuQNB6GXWqEYZcaYdilRhh2qRGGXWqEYdeikuxJ8luTrkP9MeyaiCT/muSZJE91r+9Nuqa1zrBrpJK8ZJnJV1bVid3rl8dWVKMM+zGmO73+oyS7kvx3khuTnJDkvUnuXDBvJfnFbvj6JJ9O8o/dkfSbSU5P8ldJfpLku0nOW7C530jynW763yU5Yd66fyfJvUkeT/LvSV63oMYPJtkFPL1C4DUmhv3YdBlwEfBq4HXAe49iuT8BTgEOAf8B3NN9/gfg4wvmfw9wIXAO8EvdsiR5PXAdcDnwcuBzwC1J1s9bdgvwDuBlVfVc90Xz6QXr//Mkj3VfPBes8t+gARn2Y9NfV9W+qjoIfB3YvMrlbqqqu6vqGeAm4JmquqGqngduBBYe2T9VVY902/kIcwEG+D3gc1V1V1U9X1U7mPvyeOOCGh+pqp8CVNX7q+r986Z/EHgNcAawHfh6knNWuwN09Az7sem/5g3/D3DiKpd7dN7wTxf5vHA9j8wb/gHwim74VcBV3Sn840keB86aN33hsi/SfVE8WVWHui+LbwIXr/LfoQH4W2rteBr4+SMfkpzewzrPmjf8SmBfN/wI8JGq+sgyyx7t45QF5CiX0VHwyL52fBv41SSbuwtp1/SwziuSnJlkI/Ah5k71AT4P/H6SN2TOhiTvSHLSalaa5GVJLuwuLL4kyXuAtwDf6KFmLcGwrxFV9X3gT4F/Bh4E7lx+iVX5InAb8HD3+rNuW7PM/W7/FPAT4CFWuEiY5LNJPtt9XNet68fAY8AfAJdWlW3tIxT/eIXUBo/sUiMMu9QIwy41wrBLjRhrO/vxWV8nsGGcm5Sa8gxP82wdWvR+haHCnuQi4JPAccDfVtVHl5v/BDbwhrx1mE1KWsZdtXPJaQOfxic5Dvgb4O3Aa4EtSV476PokjdYwv9nPBx6qqoer6lngy8Al/ZQlqW/DhP0MXviww95u3Ask2ZZkNsnsYQ4NsTlJwxgm7ItdBHjR7XhVtb2qZqpqZh3rF1lE0jgME/a9vPCpqDP5/6eiJE2ZYcL+LeDcJK9OcjzwbuCWfsqS1LeBm966PzV0JXOPJR4HXFdV9/dWmaReDdXOXlW3Arf2VIukEfJ2WakRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRQ/XiKrXqG/vuHWr5C1+xuadKVm+osCfZAzwJPA88V1UzfRQlqX99HNl/s6oe62E9kkbI3+xSI4YNewG3Jbk7ybbFZkiyLclsktnDHBpyc5IGNexp/Juqal+SU4Hbk3y3qu6YP0NVbQe2A7w0G2vI7Uka0FBH9qra170fAG4Czu+jKEn9GzjsSTYkOenIMPA2YHdfhUnq1zCn8acBNyU5sp4vVtU/9VKVxmbY9mIdOwYOe1U9DPx6j7VIGiGb3qRGGHapEYZdaoRhlxph2KVG+IjrGmfTmo7wyC41wrBLjTDsUiMMu9QIwy41wrBLjTDsUiMMu9QIwy41wrBLjTDsUiMMu9QIwy41wrBLjTDsUiN8nn0NmOQz65PoeliD8cguNcKwS40w7FIjDLvUCMMuNcKwS40w7FIjbGc/BtiOrj6seGRPcl2SA0l2zxu3McntSR7s3k8ebZmShrWa0/jrgYsWjLsa2FlV5wI7u8+SptiKYa+qO4CDC0ZfAuzohncAl/Zcl6SeDXqB7rSq2g/QvZ+61IxJtiWZTTJ7mEMDbk7SsEZ+Nb6qtlfVTFXNrGP9qDcnaQmDhv3RJJsAuvcD/ZUkaRQGDfstwNZueCtwcz/lSBqVFdvZk3wJuAA4Jcle4MPAR4GvJHkf8EPgXaMscq2b5j7UbeNfO1YMe1VtWWLSW3uuRdIIebus1AjDLjXCsEuNMOxSIwy71AgfcR2DaW5am2Yr7Teb5o6OR3apEYZdaoRhlxph2KVGGHapEYZdaoRhlxphO3sPbEfXscAju9QIwy41wrBLjTDsUiMMu9QIwy41wrBLjbCdXcsa9plx70GYHh7ZpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhO3sa9xa/tvq/l35o7PikT3JdUkOJNk9b9w1SX6U5N7udfFoy5Q0rNWcxl8PXLTI+E9U1ebudWu/ZUnq24phr6o7gINjqEXSCA1zge7KJLu60/yTl5opybYks0lmD3NoiM1JGsagYf8McA6wGdgPfGypGatqe1XNVNXMOtYPuDlJwxoo7FX1aFU9X1U/Az4PnN9vWZL6NlDYk2ya9/GdwO6l5pU0HVZsZ0/yJeAC4JQke4EPAxck2QwUsAe4fIQ1Tj3bc5e23L7xWffxWjHsVbVlkdHXjqAWSSPk7bJSIwy71AjDLjXCsEuNMOxSI3zEtQejbkI6lpv2bF6bHh7ZpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhO3sHduDjz3H8v0Hk+CRXWqEYZcaYdilRhh2qRGGXWqEYZcaYdilRtjOfgwYZdfE3l/QDo/sUiMMu9QIwy41wrBLjTDsUiMMu9QIwy41YjVdNp8F3ACcDvwM2F5Vn0yyEbgROJu5bpsvq6qfjK5ULWWttpX7vHq/VnNkfw64qqp+BXgjcEWS1wJXAzur6lxgZ/dZ0pRaMexVtb+q7umGnwQeAM4ALgF2dLPtAC4dVZGShndUv9mTnA2cB9wFnFZV+2HuCwE4te/iJPVn1WFPciLwVeADVfXEUSy3LclsktnDHBqkRkk9WFXYk6xjLuhfqKqvdaMfTbKpm74JOLDYslW1vapmqmpmHev7qFnSAFYMe5IA1wIPVNXH5026BdjaDW8Fbu6/PEl9SVUtP0PyZuDfgPuYa3oD+BBzv9u/ArwS+CHwrqo6uNy6XpqN9Ya8ddiap85abfoaNZvW+ndX7eSJOpjFpq3Yzl5VdwKLLgysveRKa5R30EmNMOxSIwy71AjDLjXCsEuNMOxSI/xT0j0Ytr14mtvpbQtfOzyyS40w7FIjDLvUCMMuNcKwS40w7FIjDLvUCNvZp4Bt2RoHj+xSIwy71AjDLjXCsEuNMOxSIwy71AjDLjXCsEuNMOxSIwy71AjDLjXCsEuNMOxSIwy71AjDLjVixbAnOSvJvyR5IMn9Sf6wG39Nkh8lubd7XTz6ciUNajV/vOI54KqquifJScDdSW7vpn2iqv5ydOVJ6suKYa+q/cD+bvjJJA8AZ4y6MEn9Oqrf7EnOBs4D7upGXZlkV5Lrkpy8xDLbkswmmT3MoaGKlTS4VYc9yYnAV4EPVNUTwGeAc4DNzB35P7bYclW1vapmqmpmHet7KFnSIFYV9iTrmAv6F6rqawBV9WhVPV9VPwM+D5w/ujIlDWs1V+MDXAs8UFUfnzd+07zZ3gns7r88SX1ZzdX4NwG/C9yX5Ejfwh8CtiTZDBSwB7h8JBVK6sVqrsbfCWSRSbf2X46kUfEOOqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qhGGXGmHYpUYYdqkRhl1qRKpqfBtLfgz8YN6oU4DHxlbA0ZnW2qa1LrC2QfVZ26uq6hcWmzDWsL9o48lsVc1MrIBlTGtt01oXWNugxlWbp/FSIwy71IhJh337hLe/nGmtbVrrAmsb1Fhqm+hvdknjM+kju6QxMexSIyYS9iQXJflekoeSXD2JGpaSZE+S+7puqGcnXMt1SQ4k2T1v3MYktyd5sHtftI+9CdU2Fd14L9PN+ET33aS7Px/7b/YkxwHfB34b2At8C9hSVd8ZayFLSLIHmKmqid+AkeQtwFPADVX1a924vwAOVtVHuy/Kk6vqg1NS2zXAU5PuxrvrrWjT/G7GgUuB9zLBfbdMXZcxhv02iSP7+cBDVfVwVT0LfBm4ZAJ1TL2qugM4uGD0JcCObngHc/9Zxm6J2qZCVe2vqnu64SeBI92MT3TfLVPXWEwi7GcAj8z7vJfp6u+9gNuS3J1k26SLWcRpVbUf5v7zAKdOuJ6FVuzGe5wWdDM+NftukO7PhzWJsC/WldQ0tf+9qapeD7wduKI7XdXqrKob73FZpJvxqTBo9+fDmkTY9wJnzft8JrBvAnUsqqr2de8HgJuYvq6oHz3Sg273fmDC9fyfaerGe7FuxpmCfTfJ7s8nEfZvAecmeXWS44F3A7dMoI4XSbKhu3BCkg3A25i+rqhvAbZ2w1uBmydYywtMSzfeS3UzzoT33cS7P6+qsb+Ai5m7Iv+fwB9PooYl6noN8O3udf+kawO+xNxp3WHmzojeB7wc2Ak82L1vnKLa/h64D9jFXLA2Tai2NzP303AXcG/3unjS+26Zusay37xdVmqEd9BJjTDsUiMMu9QIwy41wrBLjTDsUiMMu9SI/wUQr1LnDl8n2AAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -244,7 +246,7 @@
     "test_data_path = \"./MNIST_Data/test\"\n",
     "mnist_ds = ds.MnistDataset(train_data_path)\n",
     "print('The type of mnist_ds:', type(mnist_ds))\n",
-    "print(\"Number of pictures contained in the mnist_ds：\",mnist_ds.get_dataset_size())\n",
+    "print(\"Number of pictures contained in the mnist_ds：\", mnist_ds.get_dataset_size())\n",
     "\n",
     "dic_ds = mnist_ds.create_dict_iterator()\n",
     "item = dic_ds.get_next()\n",
@@ -293,8 +295,8 @@
    "execution_count": 4,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:37.029946Z",
-     "start_time": "2020-09-01T09:38:37.019757Z"
+     "end_time": "2020-09-04T06:46:32.459913Z",
+     "start_time": "2020-09-04T06:46:32.450854Z"
     }
    },
    "outputs": [],
@@ -307,7 +309,9 @@
     "\n",
     "def create_dataset(data_path, batch_size=32, repeat_size=1,\n",
     "                   num_parallel_workers=1):\n",
-    "    \"\"\" create dataset for train or test\n",
+    "    \"\"\" \n",
+    "    create dataset for train or test\n",
+    "    \n",
     "    Args:\n",
     "        data_path (str): Data path\n",
     "        batch_size (int): The number of data records in each group\n",
@@ -377,8 +381,8 @@
    "execution_count": 5,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:37.077669Z",
-     "start_time": "2020-09-01T09:38:37.030960Z"
+     "end_time": "2020-09-04T06:46:32.488908Z",
+     "start_time": "2020-09-04T06:46:32.460923Z"
     }
    },
    "outputs": [
@@ -407,8 +411,8 @@
    "execution_count": 6,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:37.443526Z",
-     "start_time": "2020-09-01T09:38:37.078712Z"
+     "end_time": "2020-09-04T06:46:32.855325Z",
+     "start_time": "2020-09-04T06:46:32.489911Z"
     },
     "scrolled": false
    },
@@ -417,15 +421,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "dict_keys(['label', 'image'])\n",
       "Tensor of image: (32, 1, 32, 32)\n",
-      "labels: [3 4 2 2 4 9 2 3 4 8 9 1 4 0 8 1 9 0 1 2 9 4 6 5 7 4 4 5 3 9 8 5]\n"
+      "labels: [2 4 1 7 2 5 7 2 4 7 2 0 9 1 5 0 8 1 8 2 7 8 9 3 7 2 3 9 2 9 3 1]\n"
      ]
     }
    ],
    "source": [
     "data = datas.create_dict_iterator().get_next()\n",
-    "print(data.keys())\n",
     "images = data[\"image\"] \n",
     "labels = data[\"label\"] \n",
     "print('Tensor of image:', images.shape)\n",
@@ -444,14 +446,14 @@
    "execution_count": 7,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:38.064277Z",
-     "start_time": "2020-09-01T09:38:37.444556Z"
+     "end_time": "2020-09-04T06:46:33.459883Z",
+     "start_time": "2020-09-04T06:46:32.856341Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 32 Axes>"
       ]
@@ -515,44 +517,8 @@
    "source": [
     "在构建LeNet5前，我们需要对全连接层以及卷积层进行初始化。\n",
     "\n",
-    "`TruncatedNormal`：参数初始化方法，MindSpore支持`TruncatedNormal`、`Normal`、`Uniform`等多种参数初始化方法，具体可以参考MindSpore API的`mindspore.common.initializer`模块说明。\n",
-    "\n",
-    "初始化示例代码如下："
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {
-    "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:38.071875Z",
-     "start_time": "2020-09-01T09:38:38.066284Z"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "import mindspore.nn as nn\n",
-    "from mindspore.common.initializer import TruncatedNormal\n",
-    "\n",
-    "# initialize 2D convolution function\n",
-    "def conv(in_channels, out_channels, kernel_size, stride=1, padding=0):\n",
-    "    \"\"\"Conv layer weight initial.\"\"\"\n",
-    "    weight = weight_variable()\n",
-    "    return nn.Conv2d(in_channels, out_channels,\n",
-    "                     kernel_size=kernel_size, stride=stride, padding=padding,\n",
-    "                     weight_init=weight, has_bias=False, pad_mode=\"valid\")\n",
-    "\n",
-    "# initialize full connection layer\n",
-    "def fc_with_initialize(input_channels, out_channels):\n",
-    "    \"\"\"Fc layer weight initial.\"\"\"\n",
-    "    weight = weight_variable()\n",
-    "    bias = weight_variable()\n",
-    "    return nn.Dense(input_channels, out_channels, weight, bias)\n",
-    "\n",
-    "# set truncated normal distribution\n",
-    "def weight_variable():\n",
-    "    \"\"\"Weight initial.\"\"\"\n",
-    "    return TruncatedNormal(0.02)"
+    "`Normal`：参数初始化方法，MindSpore支持`TruncatedNormal`、`Normal`、`Uniform`等多种参数初始化方法，具体可以参考MindSpore API的`mindspore.common.initializer`模块说明。\n",
+    "\n"
    ]
   },
   {
@@ -566,43 +532,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:38.091590Z",
-     "start_time": "2020-09-01T09:38:38.072888Z"
+     "end_time": "2020-09-04T06:46:33.471087Z",
+     "start_time": "2020-09-04T06:46:33.461899Z"
     }
    },
    "outputs": [],
    "source": [
+    "import mindspore.nn as nn\n",
+    "from mindspore.common.initializer import Normal\n",
+    "\n",
     "class LeNet5(nn.Cell):\n",
     "    \"\"\"Lenet network structure.\"\"\"\n",
     "    # define the operator required\n",
-    "    def __init__(self):\n",
+    "    def __init__(self, num_class=10, num_channel=1):\n",
     "        super(LeNet5, self).__init__()\n",
-    "        self.batch_size = 32\n",
-    "        self.conv1 = conv(1, 6, 5)\n",
-    "        self.conv2 = conv(6, 16, 5)\n",
-    "        self.fc1 = fc_with_initialize(16 * 5 * 5, 120)\n",
-    "        self.fc2 = fc_with_initialize(120, 84)\n",
-    "        self.fc3 = fc_with_initialize(84, 10)\n",
+    "        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')\n",
+    "        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')\n",
+    "        self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))\n",
+    "        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))\n",
+    "        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))\n",
     "        self.relu = nn.ReLU()\n",
     "        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
     "        self.flatten = nn.Flatten()\n",
     "\n",
     "    # use the preceding operators to construct networks\n",
     "    def construct(self, x):\n",
-    "        x = self.conv1(x)\n",
-    "        x = self.relu(x)\n",
-    "        x = self.max_pool2d(x)\n",
-    "        x = self.conv2(x) \n",
-    "        x = self.relu(x)\n",
-    "        x = self.max_pool2d(x)\n",
+    "        x = self.max_pool2d(self.relu(self.conv1(x)))\n",
+    "        x = self.max_pool2d(self.relu(self.conv2(x)))\n",
     "        x = self.flatten(x)\n",
-    "        x = self.fc1(x)\n",
-    "        x = self.relu(x)\n",
-    "        x = self.fc2(x)\n",
-    "        x = self.relu(x)\n",
+    "        x = self.relu(self.fc1(x))\n",
+    "        x = self.relu(self.fc2(x))\n",
     "        x = self.fc3(x) \n",
     "        return x"
    ]
@@ -616,11 +578,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:38.379734Z",
-     "start_time": "2020-09-01T09:38:38.092597Z"
+     "end_time": "2020-09-04T06:46:33.787344Z",
+     "start_time": "2020-09-04T06:46:33.472097Z"
     }
    },
    "outputs": [
@@ -628,50 +590,25 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "layer conv1: Conv2d<input_channels=1, output_channels=6, kernel_size=(5, 5),stride=(1, 1),  pad_mode=valid, padding=0, dilation=(1, 1), group=1, has_bias=False,weight_init=<mindspore.common.initializer.TruncatedNormal object at 0x000002187E2F1C48>, bias_init=zeros>\n",
+      "layer conv1: Conv2d<input_channels=1, output_channels=6, kernel_size=(5, 5),stride=(1, 1),  pad_mode=valid, padding=0, dilation=(1, 1), group=1, has_bias=False,weight_init=normal, bias_init=zeros>\n",
       "****************************************\n",
-      "layer fc1: Dense<in_channels=400, out_channels=120, weight=Parameter (name=fc1.weight, value=[[ 0.02240494 -0.03131013  0.004632   ...  0.00324241 -0.01114001\n",
-      "  -0.0169871 ]\n",
-      " [ 0.01649818 -0.0044783   0.00637265 ... -0.01819381 -0.01108851\n",
-      "   0.00254032]\n",
-      " [-0.01652201 -0.01126798  0.0103489  ...  0.00710467  0.02268368\n",
-      "   0.01119684]\n",
+      "layer fc1: Dense<in_channels=400, out_channels=120, weight=Parameter (name=fc1.weight, value=[[-0.00758117 -0.01498233  0.01308791 ...  0.03045311 -0.00079244\n",
+      "  -0.01519072]\n",
+      " [-0.00077699 -0.01607893 -0.00215094 ... -0.00235667 -0.01918699\n",
+      "  -0.00828544]\n",
+      " [-0.00105981 -0.01547002 -0.01332507 ...  0.01294748  0.00878882\n",
+      "   0.01031067]\n",
       " ...\n",
-      " [-0.02398063  0.00812657 -0.00856457 ...  0.00958495  0.0117516\n",
-      "   0.01442272]\n",
-      " [ 0.00061947  0.00622486  0.00223064 ...  0.00044143  0.00958962\n",
-      "  -0.02020891]\n",
-      " [ 0.00553562 -0.01564798  0.00383427 ...  0.01325661 -0.00454537\n",
-      "  -0.02062926]]), has_bias=True, bias=Parameter (name=fc1.bias, value=[ 1.46000823e-02 -5.65129751e-03  6.97416533e-03  8.66697263e-03\n",
-      " -5.08727739e-03  1.58108808e-02 -2.87553165e-02 -1.35715354e-05\n",
-      "  2.18758751e-02  1.21150464e-02 -3.77241150e-02 -5.88332256e-03\n",
-      " -3.64189520e-02  1.11617511e-02  2.81808544e-02 -1.81242004e-02\n",
-      " -3.39958817e-02  1.69995036e-02  2.93005090e-02 -1.72905736e-02\n",
-      "  1.62581392e-02  1.12537332e-02  2.37391191e-03 -2.55273916e-02\n",
-      "  3.85043025e-03  7.54928403e-03  5.61551051e-03 -3.75834890e-02\n",
-      "  3.58660333e-03  2.39857119e-02 -3.24539281e-03  1.38072297e-02\n",
-      "  2.08093394e-02  5.96574740e-04  1.07208556e-02  9.32972133e-03\n",
-      "  7.24232290e-03 -3.67774591e-02  3.23203206e-02 -1.69433970e-02\n",
-      " -5.22669265e-03  1.27497995e-02 -9.47343279e-03 -1.52132586e-02\n",
-      " -7.53120566e-03 -9.98139009e-03  5.41835930e-03  1.06569491e-02\n",
-      "  2.18227319e-03 -1.02072321e-02 -2.08026879e-02 -1.05009358e-02\n",
-      " -3.83294113e-02  7.36226700e-03 -1.12355659e-02  3.56015787e-02\n",
-      "  5.61804092e-03  1.66733321e-02 -2.25071907e-02  1.15467515e-03\n",
-      "  2.77944747e-02  1.17039364e-02 -2.62576644e-03 -4.32458101e-03\n",
-      "  2.01407378e-03  2.75196247e-02 -5.07531315e-03 -1.09034656e-02\n",
-      "  1.60588170e-04  3.16927172e-02 -1.59935837e-04  1.10228509e-02\n",
-      "  6.63102884e-03 -1.71946909e-03  5.14860218e-03  2.17347331e-02\n",
-      " -7.29528069e-03  3.67117263e-02 -2.61604451e-02  1.76941380e-02\n",
-      "  3.00488286e-02  2.44085714e-02  2.65124440e-03  1.64452139e-02\n",
-      " -5.00308210e-03 -1.65639576e-02 -7.67643424e-03  1.79094058e-02\n",
-      " -1.94874238e-02 -1.15548298e-02  1.11595476e-02 -1.68660898e-02\n",
-      " -1.53404092e-02  9.85462964e-03 -1.58244669e-02 -3.97545006e-03\n",
-      " -6.41824538e-03  1.47098498e-02  3.39183249e-02  3.68443988e-02\n",
-      " -1.10357571e-02  2.36922763e-02  1.54501144e-02  9.35986359e-03\n",
-      " -1.33177461e-02  1.81678100e-03  1.04002981e-02  1.36462189e-02\n",
-      " -2.00967453e-02  7.50109379e-04  1.55919408e-02 -2.26795048e-04\n",
-      "  1.40714077e-02 -5.05552161e-03  5.65858278e-03  1.06798830e-02\n",
-      "  3.98079818e-03  2.47034524e-03 -8.00383650e-03  2.06047539e-02])>\n"
+      " [ 0.01414873 -0.02673322  0.01534838 ...  0.00437457 -0.01688845\n",
+      "  -0.00188475]\n",
+      " [ 0.01756713 -0.0201801  -0.0223504  ...  0.00682346 -0.00856738\n",
+      "   0.00753205]\n",
+      " [-0.01119993  0.01894077 -0.02048291 ...  0.03681218 -0.01461048\n",
+      "   0.0045935 ]]), has_bias=True, bias=Parameter (name=fc1.bias, value=[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n",
+      " 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.])>\n"
      ]
     }
    ],
@@ -710,11 +647,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:38.387303Z",
-     "start_time": "2020-09-01T09:38:38.381254Z"
+     "end_time": "2020-09-04T06:46:33.795001Z",
+     "start_time": "2020-09-04T06:46:33.788382Z"
     }
    },
    "outputs": [],
@@ -735,7 +672,7 @@
     "        cur_step = (cur_epoch-1)*1875 + cb_params.cur_step_num\n",
     "        self.step_loss[\"loss_value\"].append(str(cb_params.net_outputs))\n",
     "        self.step_loss[\"step\"].append(str(cur_step))\n",
-    "        if cur_step % 25 == 0:\n",
+    "        if cur_step % 125 == 0:\n",
     "            acc = self.model.eval(self.eval_dataset, dataset_sink_mode=False)\n",
     "            self.steps_eval[\"step\"].append(cur_step)\n",
     "            self.steps_eval[\"acc\"].append(acc[\"Accuracy\"])\n",
@@ -762,11 +699,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:38:38.408697Z",
-     "start_time": "2020-09-01T09:38:38.388305Z"
+     "end_time": "2020-09-04T06:46:33.810658Z",
+     "start_time": "2020-09-04T06:46:33.796009Z"
     }
    },
    "outputs": [],
@@ -805,11 +742,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:39:52.156166Z",
-     "start_time": "2020-09-01T09:38:38.409703Z"
+     "end_time": "2020-09-04T06:46:57.649137Z",
+     "start_time": "2020-09-04T06:46:33.811666Z"
     },
     "scrolled": true
    },
@@ -819,21 +756,21 @@
      "output_type": "stream",
      "text": [
       "============== Starting Training ==============\n",
-      "epoch: 1 step: 125, loss is 2.2996988\n",
-      "epoch: 1 step: 250, loss is 2.2885375\n",
-      "epoch: 1 step: 375, loss is 2.2842615\n",
-      "epoch: 1 step: 500, loss is 2.2915533\n",
-      "epoch: 1 step: 625, loss is 1.0949335\n",
-      "epoch: 1 step: 750, loss is 0.09757905\n",
-      "epoch: 1 step: 875, loss is 0.16094187\n",
-      "epoch: 1 step: 1000, loss is 0.1573071\n",
-      "epoch: 1 step: 1125, loss is 0.14192748\n",
-      "epoch: 1 step: 1250, loss is 0.017596576\n",
-      "epoch: 1 step: 1375, loss is 0.0800842\n",
-      "epoch: 1 step: 1500, loss is 0.26227137\n",
-      "epoch: 1 step: 1625, loss is 0.1203058\n",
-      "epoch: 1 step: 1750, loss is 0.06940367\n",
-      "epoch: 1 step: 1875, loss is 0.021781247\n"
+      "epoch: 1 step: 125, loss is 2.3096159\n",
+      "epoch: 1 step: 250, loss is 2.3002408\n",
+      "epoch: 1 step: 375, loss is 2.3008525\n",
+      "epoch: 1 step: 500, loss is 2.3079991\n",
+      "epoch: 1 step: 625, loss is 2.2878244\n",
+      "epoch: 1 step: 750, loss is 2.3090718\n",
+      "epoch: 1 step: 875, loss is 1.6479633\n",
+      "epoch: 1 step: 1000, loss is 0.19777162\n",
+      "epoch: 1 step: 1125, loss is 0.17173\n",
+      "epoch: 1 step: 1250, loss is 0.22985725\n",
+      "epoch: 1 step: 1375, loss is 0.16031101\n",
+      "epoch: 1 step: 1500, loss is 0.12752411\n",
+      "epoch: 1 step: 1625, loss is 0.03572363\n",
+      "epoch: 1 step: 1750, loss is 0.15765305\n",
+      "epoch: 1 step: 1875, loss is 0.20735049\n"
      ]
     }
    ],
@@ -858,7 +795,7 @@
     "net_opt = nn.Momentum(network.trainable_params(), lr, momentum)\n",
     "\n",
     "# define the loss function\n",
-    "net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')\n",
+    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
     "\n",
     "# define the model\n",
     "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()} )\n",
@@ -896,18 +833,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:39:52.302283Z",
-     "start_time": "2020-09-01T09:39:52.158174Z"
+     "end_time": "2020-09-04T06:46:57.780213Z",
+     "start_time": "2020-09-04T06:46:57.649137Z"
     },
     "scrolled": true
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -959,18 +896,18 @@
     "1. 载入模型`.cptk`文件中的参数`param`；\n",
     "2. 将参数`param`载入到神经网络LeNet5中；\n",
     "3. 载入测试数据集；\n",
-    "4. 调用函数`model.eval`传入参数测试数据集`ds_eval`，就生成模型`checkpoint_lenet-1_1875.ckpt`的精度值。\n",
+    "4. 调用函数`model.eval`传入参数测试数据集`ds_eval`，就生成模型`checkpoint_lenet-{epoch}_1875.ckpt`的精度值。\n",
     "\n",
     "> `dataset_sink_mode`表示数据集下沉模式，不支持CPU，所以这里设置成`False`。"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:39:53.278595Z",
-     "start_time": "2020-09-01T09:39:52.303292Z"
+     "end_time": "2020-09-04T06:46:58.668334Z",
+     "start_time": "2020-09-04T06:46:57.781766Z"
     }
    },
    "outputs": [
@@ -979,7 +916,7 @@
      "output_type": "stream",
      "text": [
       "============== Starting Testing ==============\n",
-      "============== Accuracy:{'Accuracy': 0.9716546474358975} ==============\n"
+      "============== Accuracy:{'Accuracy': 0.9653445512820513} ==============\n"
      ]
     }
    ],
@@ -1017,17 +954,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 15,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:39:53.421939Z",
-     "start_time": "2020-09-01T09:39:53.295258Z"
+     "end_time": "2020-09-04T06:46:58.821007Z",
+     "start_time": "2020-09-04T06:46:58.671515Z"
     }
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1089,11 +1026,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 16,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:39:54.411207Z",
-     "start_time": "2020-09-01T09:39:53.422944Z"
+     "end_time": "2020-09-04T06:46:59.801973Z",
+     "start_time": "2020-09-04T06:46:58.822022Z"
     }
    },
    "outputs": [
@@ -1101,14 +1038,17 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "All the figures in this group are predicted correctly!\n",
-      "[3 3 0 5 2 9 8 9 0 7 0 1 0 9 0 1 0 1 7 9 6 6 0 8 6 3 2 3 2 5 3 6] <--Predicted figures\n",
-      "[3 3 0 5 2 9 8 9 0 7 0 1 0 9 0 1 0 1 7 9 6 6 0 8 6 3 2 3 2 5 3 6] <--The right number\n"
+      "Row 2, column 4 is incorrectly identified as 2, the correct value should be 4 \n",
+      "\n",
+      "Row 4, column 4 is incorrectly identified as 3, the correct value should be 7 \n",
+      "\n",
+      "[0 1 2 5 3 7 0 8 3 3 9 2 8 0 2 6 8 5 0 2 9 4 3 3 6 0 2 3 3 4 7 6] <--Predicted figures\n",
+      "[0 1 2 5 3 7 0 8 3 3 9 4 8 0 2 6 8 5 0 2 9 4 3 3 6 0 2 7 3 4 7 6] <--The right number\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADsCAYAAADXaXXTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOy9e3wU1f3//zy7CbkQCAQSINxCgIQolIsRioKgfgHFS+EjUBVLRSkKUv0oqPWDn4oWaq0Kv1pERW5FKBa88Kloi7YaiqBYRFRKJEAIt3ANCZCQhGT3/ftjZje7yW6y19lF5/l47GN3Zs7MvObMmfeeOef9PkeJCCYmJiYmxmCJtAATExOTHxKm0TUxMTExENPompiYmBiIaXRNTExMDMQ0uiYmJiYGYhpdExMTEwMxja6JiYmJgUSF0VWKFKV4VykqlOKgUtwZaU3eUIoZSrFdKaqVYkWk9XhDKeKUYqmen+eV4iuluDHSuryhFHlKUaUU5fpnT6Q1eUIpVinFMaU4pxQFSjEl0pq84ZKXjo9NKf4YaV2euFRsgFJkKMUHSlGqFMeVYqFSxPhzjJAbXX8F6LwMXATaAROBV5Ti8pAK80CAWouBucCyEMtplAC0xgCHgWFAMvC/wFqlyAixtAYEmK8AM0RI0j/ZIRXlgQB1PgtkiNASuBWYqxRXhFZZQwLR6pKXSWjPViWwLuTi6nGp2IAAdS4CTgIdgH5oz9d0fw7gs9FViiKleEIpdutWfrlSxCvFcKU4ohSPK8VxYLme/mal2KkUZUqxVSl+5OW4zYHbgP8VoVyET4G/Aj/z50KM0AogwjsirAdKAtVnhFYRKkSYI0KRCHYRNgAHIHADEc58DSVhvv//EaHasah/ukej1nqMQzMWm6NNa6htQJjztBuwVoQqEY4Dfwc//xxExKcPSBHILpDOICkgW0DmggwHqQV5DiQOJAFkAMhJkEEgVpCf6/vH6cdaBLJI/90fpLLeuWaBvOerNqO01jvHXJAVgWo0Uqu+rR1IFUivaNQKkgdyCuS0ftzh0ajTZd0FEAHZAZIUrVpdzvMxyJxoLKuE2AaEuZzeD7ISJBGko36esX7p8/NC7ndZHg2yX7+QiyDxLtteAflNvf33gAzzcNyhIMfrrfsFSF6QhSPkWuulCaXRDbfWWJB/gLwWrVr1Qt9Cfxh+DnIepHu06XRJYwUZAvIkSGw05qlLmi4gNpBu0Xj/Q20DwlxOc0C+RDPeArICRPmjz9823cMuvw8C6frvUyJUuWzrCszUq+tlSlEGdHZJ70o50LLeupbAeT+1GaE1XIRNq1JYgDfQ2stmRKtWEbaJcF6EahH+BGwBRkebThe9NtFegzsB04LQGXatwCTgUxEOBKkzXFrDYQNCrlN/ljYC7wDNgbZAa+A5f4T525Dc2eV3F7ROJYD6Q5UdBuaJMM+HYxYAMUrRU4S9+rq+wH/81FafcGgNF2HRqhQKWIrWOTFahJpghWJcvgqgAtwXjNMZQxBtujrh1joJ+F2A2upzqdiAcOhM0Y+7ULR2/WqlWI7Wsf6Yz8r8rLJ/C9IJrZ1kM8hv9Sr7kXppc0EO66+MCqQ5yE0gLbwc+02QNXq6q0HOglwe5GtQuLTGgMSDPAvyhv47Jkq1vgryOUG0ORqhFaQVyChHXoJMBKkAyY4ynWkgt4MkoTUvjNJ1/iTa8tRln6t0jV7TRIPWUNqAMOssBPmVXk5bgbwLstovfX5eyBMgu0HKQP6E1pjc4EL09DeA/FtPewxkneNCdGPwqkvaFJD1euE4BHJnCApHuLTOAS3nXD5zok0rSFddWxVIuctnYhRqTdXTndfTfg4yIkp1btLTnUN7sH8RrWVVX/cayBvBaDTouQqZDQizzn5onb6laJ2+60DS/NGntAM1jVIUAVNE+IdPO0QQU2t4uFS0Xio6wdQaDqJdZ1REpJmYmJj8UDCNromJiYmB+Ny8YGJiYmISPGZN18TExMRATKNrYmJiYiCNBkeMsIyPqraHj+zrvDrLm1oDx5vWS0UnmFqD4fug9VLRCWZN18TExMRQTKNrYmJiYiCBDjZtYjCVYwYCcPgWe5Npk/Kbkf7C1nBLMjExCQDT6LpgSUzk0EP9sMdBxrul2L/Oj7QkQDe4004BcKDPu02mf35Qd/5cNYq0habh9UTZpMGcy2zY5Gaphi5/2In9woUIqPr+YembQ9HY1h7z1TZ8AABHh8cTf5ofVFk1mxdMTExMDCSkNV25uh+lWQmNpmm7oyxqapD1US2SeOu+F8hplkhm6n1kL86JuNaLo3KJ++UxPsp5z+d9Hk3ZT/XUj9m8MD6Myi5NLvzXIIY8tI0XO+xosO1IbTm3nHuMmAtC2qZj1BYWGS+wHhdH5VKeHuvXPknFNTTbuD1MiprG0jcHgD1TW1I4dpFbvjo4d0OFlmboItaWJzO/7A5arfsKqa72eMxowJqayplR3YPWGRKjq3J7Y2sey8mHq/h64IpG03b761R6rOmvnbykEvuu70IhIeQUjn2NnJPT6fJ1ZHXIzNN+GdxLDUuLFtQO6NFgfWzxWQBsewtDer5RczbxZFvPZa5TTBJfzV4EQM7i6WQuraX28JGQnt8fVG5vOj61j1UZeX7td1fRcE6X9Ea27wqPsEaw9swkf1oLAA7c+hrgnq+emJB0livnvcDdZx+h2bkaYncfwXbqlCF6myKmcycALmamcionnrefeN6pE6BZ4Sm/y0hwRlcprG3bcu2Kz3g0Zb9Puxy4dbE2hypww3c3Yb0jDeyC7fRpbSRCk4A4aatw/k6zNifOUoM1tbNh+WptlQxxcX7vVzEwg02vLW6wvvvHkwHInpkGtbXYSs4ErdEb5fYqTtlq6Rab5FyXP3UROTKdLk9HwOgG8Fy5siojj7nLerH5R8a/6eT/KoUDN9bdz2qpobDG+9j5LSx2OsUk0S02yVkOBv7PNFqviKzRdZTnvQ9oY6EXTHpF35LkVl5zXvO/jARldK1t2zJ162fcmFgK+PcKBPBW1tsc3mZnT00ai68aHDX/bpciQ1bPcv4umPQKD7b+jp5bTxiWr0dXpPNmv6V+7xev7EBSg/Xbh70MwPFtMP/ECA4NClahd8YV3Eblgo4ejX8kCPa5iiZeKu3FJ9d7n1jj2LgejdaCI4WjPLexOioszUN27OBquhZFduxJ4lRig013FQ3nxBPdnMvjX93I1ORitzRJlnhymkFmbCl7Pynkn3cPjsgr0aXIgZpy7p5R95rTs/Awhfd0cW6PU7Fkx54ESzAz3vjGmQ1ZrOuzhKzY0BXM1tZE/Ru6JpRwiNDU2j69J5e7XmrPqow8+n5xBwDpTwrN2oRiJqMQ4eG5cmhNW9AwH9o9e8DvJohwULAkl79c9wqufxTV9lhsJ0563Se2ItiZjkKHtU0KHT+opmtCCROSQ1ueXQnY6Fp698L+0nk6x7g7QIzIvwWA2t+3o9mmusb8N2bfwuvJFlrddaRBG2WciuXRlP18/VJnjj6dG9FOgGhDvdiWEY/d4pZna8uTmf/M/bT6sK5B/9Csq7hn/EZDtVlbJXN0RXrIDa4rM48N4It5V5LItpAcT7bv4ujTuVyZnkO7gkoA7Lt2EpuaSv9503nv8d/TKUared8zfiMrK0YBGOr3bC87y+QnH8EWW/eH6dCqtnzVIP3Rp3MZ8ViLiLb9FyzJZfm1yxgY51/NXDzUCTytM4SYGB5pt4GcZok4arYOe1a2qhPlXRX5U+tq5Znv3kf2+lKa9pyvd5pA9dW2SeCjXm9CvRrIvqJ2AGTVM5yJ72wjEagsHUhOv+kA2HPK2TN0pTPNqow8RjzWgsqEgSSs/yJQaQFh7ZnJnqeSaW91WRmpm+9Cs43bqUyoyzNA82tctdVthr3ynIsBtf8FRVwcb/Zb6rPBzd48CUt+w6aExmhZKLR657NA1Hml2cbtpNRbZzt1ig5vKc4/WleJeDRlP4tyLob03L4g1dUkr/rc5/Sn+zRjXFuD73097h34KcMT3M3P82e68/bi60jD+x9W2x1ldPvrVK2vJ4J4ev6v+XYsvJIKQOtTlVz8ibvHQvdexVR060CCn53tIXUZm3xoKG23NP5Pl7D+C7qs137L1f3oG3cHXw9c49z+Uc57XDNtLJUMdKY3gpr0ZPZftxxo2FQSaVzzzBNlkwYz/PLIN8tMPjSUvP9ke93ec1ktakt0OsHHdO7E3gc6u7Th+Vaeo4E2I4t5KnV3RM7tCCgamPi6c93Tpy4D4K03hpPeRNCD/et8zZvp1rDKbBJvz/+pfpqJtOdUscfFToFmq3L6TW/02fSEGRxhYmJiYiAhrel+/rc+dFnme01GbdlJ+tle3PDSTbyV9TZJFq2p4l993qXbLVMAyPLzXyRUzDw2gJaFl4YLW8Jdx1jeZXOkZbD1YDd6LqsFtHsb7Tic+E8PaEV5V0XBpEW49lJvPdiNrnsqI6TONy781yAGtvl3xM7vGlDkYMX2qwDI8qEdPCYzg8JrGw+oihT/6vMu9HFfV26vYlzBbVTVam9AgdiIiI+9YN/1HdbxKTz8wfXMS/+QNKtW6Fu20fxOLb17RSSAYvMfB9F6ZWjbEgPB0rsXtW3qCmX9gBKV25tOSZFz4Hdlz9CV9I3Te9lj+mOtqIlabxR3J/5XPKZxvZ70s5Eph/WxpqZSc1kn5/LP5r3XwCsIIC32HPZhg93WBeLI3xiWFi2oGJihu/0FxqlrOrh1TgGoKK3rnLRVMLt4JJbxlcSVHAUgjiK/jxNxowtgKznDoUGw+JsrnNFCjnbe4fPHEDcyvOdXcXFcbBlFbXe6czwWhf2l83qHpYYzoETHmwN9tdSwp0YLPDESZ/v8Gq0j5ZNrM6Mu8MXaKpk9TyVz4LqmO28c13PDSzdhHZ8S1iANT9QPOvHVr3VqcjFT1yx3WxeII39j1A7oofs213WOnrRVoKqs3neKIiyJWu1ctUiiysPzf9JWQYmtrjd9/omRHBpUAVQ0SOsPUWF0I03Z+P6smfcCnpz0I4HDOT479qTuklfnIeIIKHGQGRuLJwf6l0p71Rm8CGF0gIavHF2RzvYrXsafTtO3st7m4Q+uD2uQhifqB520sHgOJokWhqyeRfY87e0m8PqvMRx6qB8Ab933gscgnSGrZ9FjgUuFpraWYA0uRJnRdXVcNxJ7jHILAY0kKrc3167QopE8BZ04Akqa4ufJ31CwoT1HR7cOW+3MXnKGhyZOR2KURwf9OBXLjYla4Eu1PZaNc4aR+E5o/G2DoXVipTP4whMDnpnGZZPy3a4nyRLPvPQPmb1tJEdHx4UtT1Vub4Ysq3O3DIWT/oBnptEmv4rMwkPUBiuwCayVCvv582E+S3AULMnl3oGfOj0uXNujXVk4bgm/tGl9SxmzQ9fUGFVGV7bv4kh5hvHnreePm7N4Opn/Kg57Aa3PxVG5dHxqn95cEFxzR5q1OQs6/pNx626jujYDgMpVHWgVwnZqqa1FbdmJAmfAQd3oUZr/tSPwBaB0diJf3p9ByYfpgLEBB66oF9tyZfo0r9vbb9jH0QM9GgQcpFmb80i7j5gZMyZs2mzNY+sNyOO7wXV15Hel/YZ92E6dMrw8e6N41lW0Gam1Qw9t4/4nHK5nzxHI0zqxkuXdlzXwKQZ9lLnnHuOJh1YzIeksIxNruNg+9JGKITW6P77xW3Yd1hrvU5ZFvhMqUDp9UhmRYf3K02NDWstPssTz917vO5dzMqfTKmRHd8cRcJB8QBucOid/OlXta92c3l/ssAM67ODpdrofJ8MjYng9BUe4YgOabTxFZcJArpk2FtB7soH2VtjzYkeyn04K+Qho3rjm27Gc+qyDc7l+vjrSOBz5U9a7P3u28Eusw4eAovKci3zb290t6aStgiGrZ9Fz6aGQdvbJ1f3Ye08Mljgb26942e0NZ/KhoQB8/nfNRUEUVPerISP2NOEc8yJgoxtbfJbuH09m+7C6C1neZTOTp2rbd9cO9rlW5Tpjwz3pxoay/pBIHXzMOe1PuIJOrHnaOLVd8jQPgW6x2uvZX657xRki6nDkT7y7+pKb4aK1NZH91y1nxOuTsewN/fFji8/S7W9T3NZ1fs9Cl/VaHln65vCd7nXhyqnPOjjTRJKmypi3QJ4Sm6LHgv3UNjJOgz84ZqY4PK2WA0OX6Gs1OzUi/xb2FbVzBr50WbbVGRyz7Yb/z+lBFS7M4AgTExMTAwm4pmvbW0j2zDSOb9NGgnLgcNKf+VAF/7IOxlojXkdaj8nM4OSwDtQmKjZOqxtoBGD1+TYAHN3RgcwAfOF8weEcX5IbHf2sScU13FU0PKAmhufPdOf9Yu016Yo2hzzOjGB00IltbyFZ92qv4D9dMo3l17q3pT2asp+uD642fNYAx2wMrZ2DyLgHclz4r0FUeRmcyeEcH1NSGZbeedc888TpAa0a+BVHUyCPpzKm4uIoG98fW6zimhkNZ+0oqKng9p1T6Fjd0N84UI4O0zx+9gx1d6+7q2g4tb9vR8/yWkqztJrumcmDPQbHPH+mO0n5PvRa+0lwbbq1tcw/McItqMHBix12wLwd2hCELiOtu1J4bYKLY7S798CTn2ptaVm/Cl/bcNGY1pqOsZqGaqnhpdJemlN/2M7qnWYbt3Oiqj+syfNrv7Xlyfz51brX9C/+axBz59RNAji19ZekWZvz4YVYmh2PjD9y1pTtTF5yD3+5/hW3kagmJJ2lz9z5zPxoTKNDAIYSmXmaf/de73yNz9riPoOFt4ADgMO1dix31GA7YWyghGMGg/KuDRtNoyWQx4EjsMk+TJsh5mLLWNbMe8Gjh1BBTQUTv51M+zH5hrQ9716ZQ5uqKk48Wu11lpvFZ9M5WdOStxdf1+TYEYEQlNF1BDXM3jaSBR3/6QzjdcV1RHhfOFJbznm7JSIO1oU1NXxyfXfkRHRGUXniQE0585+5n7RVdYUj8Z1tbH6n7l4c3DaSR9p9xMNLZ5HxbOgLkbVNCsTUK0rV1djLK7C0qeuyypl9iDvip+oDi+jJIhTEAWCJ0x5za7s0rzNYuBIprZYWLVxmMHCvuR2oKcdSGx21XAeuATJ1uBvcUptWKRj/1RTajzFuHsIdv24YfVhur+Jwbd17y1tTRqK27Gx0dLRgCIn3wtHRcYxbd5tbT3mg3PLcY3R4ax/ZF7TOluh48Y9e7p7xiDaubiNpjo6OY2bMGLqc3xmW/Oz4QTWPtNvgtu72nffS7vk4Fqx2NxLa0Hl1PciRDOJwnZ3C2wwWrkRK657fXcbnt76gL7m/Ufpy/6OR3E0PAJA9o9BY7woPjCu4DcsddW/ilpJdYc3PkBhdW8kZLA/2YkSbyc51R9yaDhrHdRaEDrv3RlX0ktHE7NjHsPumsmLh/EYDNhx5lpiXj72JttBwh652TShp4GC+rv8S8pb09Op47qDaHhux++06O4U3XGdssFbUIKeMfwuSeJvXHvVm52oiNoOur2W1Pt3+OpWcF7U/LlvZ2bBoy1x2CIAReZObSKmNZ2Jkc1HI/HTtu75zc4XIPJzBlQe9O6C7Yq0R5ywIRv7rZawvBSAz7T4Kx75m4Jm9Yz9/noQPv+aO2bPcZg6ojyPPmjK4kSIrtjlZXtpFHYR6VohQkvnufbTZbnGbsSGaapMOR/4Ou/dGrKboWlYf+fUaJiQ1bkBzFk8n6aDQa0dZ2H2cHb6+Fh98fo1+mw5bRFptYREpfgQYRKJA27/W2pKyF+eQc2o6lmrocj7yQxL6OnNAtBiBtxdfx+q21/HjG75tdIjJ+jNHhGNWCF+oXNWBnMzpjabJfrfUWT6ikfN2Cx3e2hfxt0JHWX221USeatt42kw98OGH3mQYVWHAkcL+dT5d9Ck3fugFIhAcXhO7Dg2m29XRP3NEq5WfNRmZF03loO2WWLrhHjChqqzOfo9owJcAl2gJQ440ZnCEiYmJiYGYNV2TkJGy7DNSlkVaxfcPb/kaTbVxE98xa7omJiYmBmIaXRMTExMDURJF06iYmJiYfN8xa7omJiYmBmIaXRMTExMDMY2uiYmJiYGYRtfExMTEQEyja2JiYmIgUWF0lWKVUhxTinNKUaBUvZjHKOIS05qjFB8rxVml2KcUYyOtySNKxaHUUpQ6iFLnUeorlLox0rI8oRQZSvGBUpQqxXGlWKhUdAYZKUWKUryrFBVKcVAp7oy0Jk8oRZxSLNU1nleKr5QiKu+/A6W4XSny9bzdrxRDfd5ZREL6AYkJYJ/LQeL0371AjoNcEWptPyStIDEgBSCPgFhBrgOpAMkKt1YB//IVmgvMEcgQsAjcLHBeICOa8lTf5wOQFSDxIO1BvgV5MNruv77PGpC/gCSBDAE5C3J5tGkFaQ4yByQDxAJyM8h5kLDe/yDydQTIQZAf63o7gnT0eX8/TlQE8gTIbpBSkOV6wRsOcgTkcd0AvaGnvxlkJ0gZyFaQH/l4nmyQYyATgsjIH7xWkN4g5SDKZd2HIL8JuJBCkcATArsFSgWWC8QLDBc4IvC4wHGBN/T0NwvsFCgT2CrgU77q+34jcFs05ameNh9ktMvy8yCvReH9bw5y0fVPFuQNkN9Fm1Yv5/oGJKD7b0AZ2Apyb8Da/LyIXSCdQVJAtoDM1S+iFuQ5kDiQBJABICdBBqHVsn6u7++oIS4CWVTv+ItALoAIyA6QpCAz/AetFaQPDY3uRyDvBqpVN7q7BDoLpAhsEZirG91agecE4gQSBAYInBQYJGAV+Lm+f5x+rEUCi7ycp51AlUCvaMpTffl+kJUgiWg1nF0gY6Pw/vcHqax3rlkg70WbVg/naQdSBRLQ/Q9zvlrR/sx+BbIPzYAvBEnwWZufF3G/y/JokP36RVwEiXfZ9gr1alQge0CGNXEOK9pr0JMgsUFm+A9aK0gsSCHIY/rvkfrxNgaqVTea97ssjxbYrxvdiwLxLtteEfhNvf33CDSarwKxAv8QCLb2GJb7D5ID8qX+4ApaU4OKNq0gQ0GO11v3C5C8aNPqodz+gyDeHsKcr+n6fd8O0gGkLZpBn+erNn870g67/D4IpOu/T4lQ5bKtKzBTKcocH6CzS3qPiGAT4VOgE+DbtBOmVo9aRagBxgA3AceBmcBaoOmh9APUikgDrShV5vw0la9KWYA3gIvAjHDpDDRPlcICbATeQZusrC3QGngu2rQC5UDLeutaAuejUCvgzN9Q3f9waa3Uv/8owjERTgPzgdG+ivK317Wzy+8ugGM+FqmX7jAwT4R5fh7fVVf3APd18IPXKsI3wDDHslJsBf4UhE7wUysivuWrUgpYCrQDRiNS08QeIdXpY56m6MddKEI1UK0Uy4G5wGNRprUAiFGKniLs1df1Bf4ThE4IU1lVCrf7r1cagiXkWkUoVYojHo7hO35W178F6YTWRrIZ5Ld6df1IvbS5IIfR2kgUWqP+TSAtPBw3DeR2tB5WK8gotF72nwT5avGD1qqn/xFa50EiWnveAfR2qoA+WvPCtwKd9DbdzQK/FUdHmnvaXIHDepuuEs1D4SYBj1oFXhX4XCDg9nGD8rQQrT0vBqQVyLsgq6NU65toHgzNQa4mSO+FMGt9FeRzgugfMVDrMyD/1u1Ba/3YPndQ+3sRjt7AMpA/6Q9zg4vQ09+gCytD6+Ff57gIPYNf1X+ngmzS053TM+oXIcjwH7RWffl5tJ7bcpC/gfQIqjC7ey+UCfxJINGj0dXS3yDwbz3tMYF1TqOrGdlX9d9dBUS0zrNyl8/EKMzTfiB5er6e1tOmRen9TwFZj1YxOARyZzSWVZCu2u2XKr2sOj4B3X8D8jUWrXOtDM0D4iVc2oib+vg8tKNSFAFTRPiHTztEEFNrmFCqCJiCSFRrvZTy1NQaHqJZa1REpJmYmJj8UDCNromJiYmBmDNHmJiYmBiIWdM1MTExMRDT6JqYmJgYSKPBESMs46Oq7eEj+zrlbZupNXC8ab1UdIKpNRi+D1ovFZ1g1nRNTExMDCUqB182+X5SPOsqynMuNlivqqxk/2o39vPBDgtgYtI09cthUn4z0l/Yatj5Q2p0K8cM5FQ/z4fMXHqI2sPBjrUSHix9cyga29rjttSdtQAkrP/CSEnfO07OuIpJd2/k0ZT9DbblX7zAzGfGgGl0fcaSmMihh/phj6tbF41lNaZzJwrv7dJkOks1dPnDTuwXLoRdU5uRxXzbe71zeXjnMfBC2E/rxGxeMDExMTGQkNV0L47KJe6Xx8jPec/j9hymk7kyhtrColCdMmgsfXMA2DO1JYVjF3lMMyL/FgDOtB5M/Fk7ie9sM0zf9wEVF0fZ+P488eBqJiSdjbQcn7k4Kpfy9NhG06RtOhaR8mxNTeXYhJ5snPZ7OsUkOdc7yurFylyabdxuuC5PXMxMJX+q52fLlSO15dxy7jE6rN2L7dQpA5RFjpAZXZl5mo9cDG5BTQV5F3oyNVkbTS1/6iIGFk2jdRQZ3aIxWpOCN4ML1F3TPJh7uheb34k3QloDYjp3ArRCXJ/Y3UeisqBaWrTgwvAc1sx7gW6xSU3vEGFUTAz2Qb2RGEXHp/axKiOv0fQ5i6eTubTW0GYza2oqx2/rwVezFwHueeooq3c9NZzTJb2R7bsM0+UJa2oqp3J8e146xSTx1exFjNg1Gcum6CvLoSTkHWmlNq1NZvxXU0hbEM/UNctDfYqwYRM7+2sr6RrTjDjVeC3HSCwtWrD3AW1o0IJJrzTY3n/edNovrzCkPcwb1lbJEBeHXNDGeJaLF7kwPIdNry2mvnEwEhUXh6VVsts6e9lZpLq6QVpLmxQWrF5ETrNEn46dP3UROTKdLk8bZ3RP39SDHb9uWAZcWZWRx9xlvdj8o8hUEBz4ovWHSMiNbu6mBwDInlFITd/MUB8+rOyvreS/b5zMtWu/9NjhEyn2/O4yPr/V0dLfvMH29x7/PaNaPkanZ43rga3P0RXpvNlvKTe9/zAAaZ8p1sx7gUgaXICy8f1ZPne+27rJTz5C8qrPI6TI5IdOyI2uvdoKgK3sLDE79jHsvqmsWDifbrFJzPqfP/Ns0kTSFkbOOLiSuewQADlqOvlTF9E1phnXrv2Snyd/gyfjFikk3kaa1bueTjFJLLj3dX6ZNEhMT1kAACAASURBVAWAjNmfGSUNgDMbsljXZwlZsc15c/RCAIpGtI2KJgV7jGpQc7XHePZbt5ec4aGJ05EYRbtnD7g1L9xVNJzdK3Ma1Nz+8LPX+WWz8Of7yRlXAfDEg6vd1g94Zhpt8qs4+XAVXw9c41w/tfWXHNw2kqOj47CVnAmbLn+0gtYk0+mTSufykWsTfGrzDRVnNmSxOns50Jy+X9wBQPqTgt0wBWH207WfP0/zL4qoEs1JYkLSWZ5qE84z+oejLS5zZQxXHpxGbaLivcd/T5q1obGYeWwAX8y7kkSM7Ugr/N1g5g5Z22D9kdpybnnuMZ54SOugGplYw6/HaenmWCeQ+avwG15rq2SOrkh3GlyAgXGx+rdvnWZry5OZ/8z9tCr7KiwaxYN9HfrLbXx5ZwYlH2pTYDl8NKW2FrVlJwo4+nQuV6bnOPdJKq6hTVVVg2ONTKzhYvtQzCzjneJZmrsd4OyMdNz/Dm9rHU/tavuR/eAkAPYMXUmatTmPtPuImTFjwqrNE1X6M16/4zRn8XQyVxa7dT4mZQ42UBn8pMs3zrJ6rkT7br/Lc6dj8ayraDOy2G1d6YUEOt5djK0s8E7hsBpda89M9jyVTHury0qvwXGRo7awiFSrhT1PJdNcefai+7Kki+GeC0XzBjNn7Fomtihxrnv+THeWvTVK82tcvpNn1UQO3q/5vzrTjV3LM7YJ4a/xxsXxZr+lzkLcGN3+OpXpQ/7ZoNmmoKoDyas+D2LCqcZpu6OMbn+dyoFbFzvXvdhhB3TYwdPtLgPgLYY3cI5vtnE7KfWOZR/WP0wqG6c852KDfDtvt9DhrX3ODlS1ZSeWEVoNk6FGK3Sn4ybtzyn7sknsGbqSk7YKhqyeRU8XX/3KMQMBaHVXdPruF8+6inE/y+Op1N1u60ttF8hd+ADZT5/FtrcwoGOH1ejWpCez/7rlgPZ6NyL/FqcDd7RRXyvA5ENDyftPNqBHrVBkqKaf3fKJm8EFeL+4D13maAbC2yvRxBYlHLjlEzbPjmxHiis91tTwfmYfw9vK7V/nk/NiJt2TJrN92Mu0ttbdX8cDlXh3NX+uGtVos5elbw4FdxjfuVo2aTDDL3f3QviiuobbP3iY7AvuBsHxbI3Iv4WPct6jjVXY93B3er7czFgPi7wdAHSt6Ue38ilaxOG8XdS6BL84gqi8uZhGksYCeVpbE9l/3XJGvD4Zy14PO/uAGRxhYmJiYiCGjr2w/7t02rS2UDlZa8dJKq6JGiduT3z+tz5kPR0dnX6rz2sNZQePtqHt5A7O9ZEKOrCmpnJsXA9aWBrvgii3VzGu4DZiSiop2tGB1V3bNKi9hxvb3kKyZyQzfMW9rOu/pEFzyKMp++n64Grml91Bq3VfOd3J5Op+lGYlAFCSa+fAra81OPbzZ7qTlN8sbNoT7jrG8i6b3dZ9eL4PPR/Y1uBNxxH+e6b1YJgHadbmFEx6hRF/m4wlAiH4astOsrZov121ytX9sOeUu6V1LSdGdmp54rapHztruY7nbkd5V61ZKgQYanQLx74GY+uW7yoazomq/qhawbJtF1IbuaYHa0UNz5/pzoOtv3P66FZ1qHW248WUVGLf9V3E9P0+fyQA8Qfj+Pc843p7vVFzWSePDvqunLRVMLt4JJbxldhKjpL5K3gydSwTb1xinFAdW9lZ2o85y8QNk1ndZ3kDwzsh6SxXznuBu88+QmJePnTtSPGj1Xw9cIXXY64tT+bPr44iPUq8cRyoqBrksCF774nhwFD3MnC41o7ljhpsJyL3jHniyU81g5W6ORZ+G2VGt/RCAvkXL6Cq6nrNVK2Qf9HdYb+9FWe72qqMPFiTpw14MmgMthMnQyXHb2T7Lj65NpOeW09wY2IpcSpW63y5Vds+fNcY4kZGTF6dO9DAyGnwl8WlV3BoUAVQEWkpTlJuLmD8+inkXbHUrX0XoFtsEpteW8yw+6aS8PBRvu71fqPHeuG3d5K2InwG19omhfgYd8+IcnsVByvbEE156o36gSn2kjNYkppjibO5pauWGvbUpIE9yv8tQkTIjG7Hu4uZGTfG2bhvByzbdjFzkLvLyp4XO+odVtGH7fRpFl81mL2fFEZVcIRJaOl4dzG5Cx/wWg5XLJxPqjUGiGxHZMcPqlnQ8QM3HeMKbsMyvpJLwejWD0x5aOJ0jj1azfYrXsa1w/ql0l58cm0mttOnI6DSeEJmdD35rUltbYPaa/bTSXQrnwrg5sYTFYhgO3WKf949mK9f6uzmHL84ezUTN0wm5eYCw+R8ek8ud73U3qcxAJr1K3Vzjo80dxUN5/SDnYDIxv97wlZ2luynz3oth96COhafTWfd/aOcy21378PmMWVo6JpQQpJFM7iujvy2kqNhPGtgnNmQxU+6fOO2Lit+jVtgyrglHzI8cS+t6wX6VNtjo2LsEGubFDp+UM3U1lsIZ3CU4YOY2/YW0usVbRDQTNt9WjtvlCHbd3GkPMNtXVZsc37S5Rs2G1j7ke27OPp0LiMea+E2mNDa8mSef/ZO53LmpmJ2d25rmK7GcIx0Vfv7djTb7t5J6i3Qw0HBkly6dtFqO/UDF0LN4Z+0Z/qQjX7tc7KmJZZNdUEc4TS49WnKkd8VTwEh4cJTgIw3tMGv3NNEKujIIzExPNJug1v059wh7wKwo1/X0J0mZEfyg4puLQDo3qu4iZQmzTZupzJhIDn9pjvXxZ+GtOV1xujQrKu4OzcvAuoaMqSt1iyzYkI7ml0z2C1Ao+OAYx49FywtWrDnd5fxl+sXOiPaGgtcCIaieYO52L6Gu3PzmmxCuubbsZz6rM5TJP40pBH+TjNHfvymxULAd99gowMOHMFP2694uUHt1VcGJB1kwxWDyPxIu2aJt9FzmRYZGA04yqvj2xnoUXiYQLv9Qz5zhIPGRq+PpGP0yRlXUdUWOuZVOZ24PaW5M92/WlA4SVj/BV3We9/eZmRxg8iZSOHQ8dSNu/nwQiwP1fzCue0eD3k6MHE/K2dfy+e3vuBWw3Ac55ORWUGP6u86e8Eff/o6IxN9C9s99VkHZyCKkajEBN6/aYHPo505qP9cldoukLvpAbKLz4a8Vm7pm0P+tBYcuG4x3gKKemSccHtD88TEFiWk/nQJM6xTnGXgyk+nkbIlxII9MPzyPQDsnjSYVit9i94ssSl6LNhPbRCd/mZwhImJiYmBhHzmiH1F7QDIaqRmFrZAey9YU1M5dXMPoC6YIEem0yXPPV1jsxzkVVpY+sUQsoiuYI4L/zWIgW3+7bYuWrSOTKxpcgSpkYk1+hjB4em4iMnMoHBSemAjWUXKg6m6mtt3ugdy9Mg4AWjPmaeAIk8BB8dtkD3zaFhcMU8PaMWBW91HXJt5bACf5vWmrVaBZH9VOuR42Lke4S4D3nAEncx8qIJ/WQdTm6gaDfYpqKng9p1T6FgdXLNoyGeO6Hte62W1D+uPtaKmwej11p6ZVHUwNgii5rJO/Hue98GUramp1FzWiYstY73OcjBn/61kTYkugwswas4mnmzr7lAerVr94YtqrQng4KG2ZAUx5sWpazp4NbiOc3x4vg9pseecs5xEGkcgx9pvrnDeW2+zQqjc3tiax3Ly4Sr2uHivnLRVMP/ESAhTwJGnAIwP3vsxif1K+fckz140i8+mc7Kmpdu6rPhjbhWcxWfTiT9rbEzaix12wDxHU6Nnz5WCmgomfjuZ9mPyg26qCXlHmtNtaY0WIvnJ9d2BOsfoPU8l6+1AGpFyjLYlCNZ2aQAcG+eY/gRcM/2krYISm9YVXHohgfaGKoxuPAW+NEZmbKzH2TiqpYbCmoZtrLd/oA2GnvVA+Hq179iiuYxlzzxKxcAMpr4WZS6MHliVkcfzK+qeq2tXfOaxQzASgSne/twcM7K8NWVkgw6yDXfdQR8XX963powkcUv47vnByjaU26ucrnhN4ToTTvsx+SHREFbvhQdbf8fN274Fos8x+tOJL1Byu2ZQtVeKhv9wQ1bPoscCrUB3rC421EUo2vEU+NIY1/5zv0fj8FJpL6cBccU1yCZcbB/2MgDHt0G88lwGohHX5yozNhZ/PBwigWNGFkvBrgYtNq3WfcXMj+rKkaWkYZpQcnR0HOPW3cbfm4g2dOA6E06onv+wGt04FUtOM61AeHKMdjjQy6nwOtDXn8ECtMFA0qze98lZPF0b/zOCocmN4cmR28iR8D0FvjRGtb2hYXDe/xORCaBwhAG3bqQcRBJvwTGuz5UrjvuftiAea0UN0RCYsvhsOm9NGakZXA9NHVJdbWj4v63kDJYHe9F37h1eg4kcs3EAZBdrTR/BDFpen5AZXfViW65Mn8a5G7TXmT1DV7pt9+QYfaS8FXEGzFhafwaLpnCOcB+BkZl8xoMjtz8O9Eazcc4w/i/5Wrd1ScU1DQIoQk3qv45x5ey6WUFcpyyPdrwFx3jDef83bQ97H6AvARjOwIct2yLWJ+kJ+67vaPd8P67MmuZxe/sNdYPDh+PtNmRG1zHSfvKBAQDk5E9vfAegZaEQZ9DA4HK+nHGvzcIe13TaTJcR7k1CQ+I72/DP6zQ01BYWkVJYhCUxkVEtH3Pe/x/f8G2DIRMddPvrVOKPxzhnQIgknoJjvNHZwAkC2u4oI2dx45paFgqt3jF2vj5fUVt2evUFDnczYsibFxwBB/XdsSKN/cIFn2fLjc65LRpn8qGhtN0S3W17kaT+/d91aDDdrs72mDbnxdMBT8USDpoKjokE9q/z6fJ1pFVcmpjBESYmJiYGEpGxF0xCgO5A3zpRm866clUHUnwMZTSBlGWfkbLM8zbTS8UknJhG9xLF4UDvwKi2cRMTk+AwmxdMTExMDESJRJMzh4mJicn3G7Oma2JiYmIgptE1MTExMRDT6JqYmJgYiGl0TUxMTAzENLomJiYmBmIaXRMTExMDiQqjqxQZSvGBUpQqxXGlWKhUdAZuKEWeUlQpRbn+2RNpTd5QihSleFcpKpTioFLc2fRexqMUcUqxVNd4Xim+UoobI63LE0qRoxQfK8VZpdinFGMjrakplKKnXmZXRVqLN5RilVIcU4pzSlGgFFMirckbwWoNudEN0FguAk4CHYB+wDCg6WGVgiQIwz5DhCT943nUlBAToNaXgYtAO2Ai8IpSXB5SYR4IQGsMcBjtvicD/wusVYqMEEtzw1+devr/AzYAKcBUYJVSZIVBnqdzB8rLwL+bTBUiAtT6LJAhQkvgVmCuUlwRWmUNiYRWn42uUhQpxRNKsVuvkS5XinilGK4UR5TicaU4DizX09+sFDuVokwptirFjxo5fDdgrQhVIhwH/g6BG4cwaw0p4dKqFM2B24D/FaFchE+BvwI/izatIlSIMEeEIhHsImwADkBgD10Y738vIB1YIIJNhI+BLURhnroc/3agDPhnoBqN0CrCf0Sodizqn4ZTinwftIqITx+QIpBdIJ1BUkC2gMwFGQ5SC/IcSBxIAsgAkJMgg0CsID/X94/Tj7UIZJHLse8HWQmSCNJRP89YX7UZrDUP5BTIaf24wwPVGU6tIP1BKuudaxbIe9Gm1cN52oFUgfSKJp0gfUDKQZTLuT4CeTca8xSkJUiBfuw5IKuisay6HH8RyAUQAdkBkvR91OrvRdzvsjwaZL9+ERdB4l22vQLym3r77wEZ5uXYOSBf6pkhICtcC3aAGR4urYNAWug37Ocg50G6R5tWkKEgx+ut+wVIXrRprZcmFuQfIK9Fm05dWyHIY/rvkfrxNkabVn3bH0Ae13+HyuiG+/5bQYaAPAkS+33U6m+b7mGX3wfRXrUATongOsx+V2CmXlUvU4oyoLNLeidKYQE2Au+gzefTFmgNPOentrBrBRBhmwjnRagW4U9or5ejo1BrOdCy3rqWwPko1Ao4y8IbaO3QM6JNpwg1wBjgJuA4MBNYCwQ7zUg4nqt+wP8DFgSpLexaXRGt2eZToBPgeT6dS1yrv43InV1+dwGKHeevl+4wME+EeT4cM0U/7kLR2kmqlWI5MBd4zE994dbqCQF8mDGqUcKhtQCIUYqeIuzV1/UF/hOU0jDlq1IoYClap99o3cBFnU4RvkHr8ANAKbYCfwpCJ4RH63AgAziktNKZBFiV4jIRBkSZVk/EEESbrk50avWzuv4tSCe0NpLNIL/Vq+tH6qXNBTmsv4orkOYgN4G08HLsQpBfgcSAtAJ5F2R1kK8WIdeqaxsFEq9rnQhSAZIdbVr19G+CrNHTXQ1yFuTyKNX6KsjnBNGOZ5DOH+n3PxGtjfwAettfNGnV9bV3+bwA8hZIahRqTQO5HSQJ7ZV9lP5c/eT7qNXfi3gCZDdIGcif9Bvb4CL09DeA/FtPewxkneMi9AfsVZe0/dA6qErROqjWgaQFmeEh1wqSqqc7r6f9HGREoDoNyNcUkPV6oTgEcmc0agXpCiJonWflLp+J0aRTX35eL6flIH8D6RGNeephvzmEpk03XM/VJj3dOTRj+Yvvq1afx9NViiJgigj/8GmHCGJqDQ+XitZLRSeYWsNFNGuNiog0ExMTkx8KptE1MTExMRBzuh4TExMTAzFruiYmJiYG0qif7gjL+KiqBn9kX+fVH9bUGjjetF4qOsHUGgzfB62Xik4wa7omJiYmhmIaXRMTExMDMY2uiYmJiYGEbXYGS98cisa29mufzKWHqD0c7NghJiYmJv4R07kThfd2cVvXMa8Ka96OkJ/LrOmamJiYGEjIa7qWvjkA7JnaksKxi/zaN4fpZK6MobawKNSyLkku/NcgqpL9/19MKq6h2cbtYVDkH9bUVE7d3KPB+tYFlQCoLTuNlnRJoOLiKBvfH1usIm3TMZ+eB7m6H6VZCUBk7r+vZdXX6zGai5mp5E91t1c5Mp0ueaE/V0iNrrVnJvnTWgBw4NbX/N4/f+oiBhZNo3UU3pRIMGrOJp5s+53f+91VNJzTJb2R7bvCoMo3rKmpHL+tBzt+/UqDbX2/uAOAtJj+WCtqIqYzpnMnQHvgvBFbfBYA295CQzQBWFols3zufHKaJTLwf3x7HvbeE8OBG7W8NvL+q5gY7IN687N57zE1ubjJ9L5ejxG43v+SnPgG26s61GIf1l9LW1KJfZf/z6LH84biINY2KRATw56nkjlw3eKAj3OgphxLbVS5212SrMrI4/kV3fnk2kxsp09rA3gZhCUxEYBjE3ry1WzPbzpfD1yj/VgDc0/3YvOPGhb4cGNp0YK9D2jDrRZMavjH4KD7x5MByJ6RjK3srCHagmVVRh5zl4U3X1VcHJZWydCmFS/9+WWyYpsDcNJWQYmtzkU1XtnpFpsUNh2B4sv9P3DrYm3aSeCG727COj4FW8mZoM8dEqPb8YNqHmm3gfZWgMSAj3P3jEdo9eFXDUYYNvGfB1t/R8+tJ1h81WBsp04Zdt5DD/UDYOO036ONmx2d7PndZXx+6wv6UnOv6bYPexmA4Svupf2YS8PoGkHZ+P4snzsfqxK6xyQ41w9ZPYseC/Y7lysGZrDptcArYuHC1/vv4K2st3n4g+s5NCj4c4fE6HZNKCGnmWdje6CmnLtnPEKzczW0e/YAqzLyvB6n2bkapLra63ajOLMhi590+cbn9G+8dy0AGbM/C5ckrwx4ZhqXTcpvkK9xKpbs2JNgCXZSC98pmjeYP/70dQA6xbgb3AHPTKNNfhUnH66qq+lGiIIlufzl+oWkWZt+2FpbtXK9rv8SJm6YTMrNBeGW58as//kzzyZNJG3hVr/2m9r6Sw5uG8nR0XEhqZ3Vxx6jGjzzOYun03PpIWpPnHSua3auY8jPHSz+3H8HSZZ4uiaUcIjg3x7C5jIGsLY8mfnP3E+rD79iz8t9mN3uX+E8nd+UTRoMQMJdx9zWr85e7nxd8oWl7YeEVJe1VTJHV6QzIXkJnv6F15Yn8/yzdwLQfsM+jh7owYjHWvBRznsh1eEvF9vXMDLRfZadI7Xl3PLcY3R4ey+2U6c4NynXbfuE5C9Zt34KHe8uNuz1vWuX0wyMi3Uuzzw2gH8tdK/CXDNjGy92qHMXyoptzk+6fMPmEDx0/jAh6SxPtfF/vzRrcx5p9xEzY8aEXhSQ+q9jXDnbfVqwzE3FTbp8inF1ACeW3r2onF83Jdry7svc7r/RhM3oPn+mO39+dRTt/+9b9szvx1+uX+j1Qk/aKhiyehY9Cw9TGy5BHjiXqZWAbb3X19tSZ+gmHxoKwOd/7+P1OJ13hlh1XBxv9lvq1fAXVHUgZblWq7YBzTaeomBCLuS4p2tvhT0vdiT76SRDO4IcfHghloeXPkaX5TuxXbgAQOf3LFzTaSwA/+rzLlmxzXmz31JmxoXHODSG497uXtSblJXubymf2gYzeXpzlnfZbLiuBkTAUDVFbWERKfU6xOo/BXJ1P04+XEUkkav7UfxoNV83eMb94/kz3Xl78XWk4d8bhyfCWtMFUIkJvH/TAq/ND19U13D7B4+QPW8XteeDnajWdyrHDCR18LEm0+X9JxuArDnBZ3YwPH3qMgBWbL+KZsdjyaDppozW1kT2X7ecEa9PxrK3yeRB03ZLLN2Y4lxudjyWjGe3YndJk7D+Cw71u0pb6OO4/w+TfWF3+AUCJ2dcxZ3pGwGXe7uyYV62WvkZecNyIRqMboC0sQr7Hu6OtaoHGe+WYv8639Dzl2Yl8PXAFc7lvl/cQTvdXTDc2IZrc28enlbLnhA0Z71f3MfvJh5vmMERJiYmJgYStpruoyn76frgap6VibSw2D2myau0MPmTaWQ9sA3PKcLDxVG5xP3ymE9toD0yTjj3iWTAwYrtWu0w617PGpLym/H8IG0W6EdT9ntME25Sln1GyrLG08jV/bDnlDuXPzzfh54G3H9HwMETD65mQtJZnj/TnaT8Zl7TXxyV67z3ESdAd540a3OnO9SVB6eR8nUINQWiZ0E8astXhpzr6DCt7X3PUP8CtIwgJEb3/w79iAnJXzZog5yQdJYJsxfhzXVozv5byZpirCFTub3p+NS+Rr0oXHEY5uEzx8DGMAoLkvQXtrKs+SgAHr0v+gqag733xHBg6BLDz+sacACwbN0ourzg+XXR3zJyKaAM9MN0BB2Ud3VvjC7JiacN/RukNyJAplpqeKm0F9V2rV9pZItv/epM65RUxolh/VG1gmXbLqQ28H6ckBjdlJsLGL9+CnlXLHW62DRGqU3rVCm9kED7UAjwgyHLtnuM8qqWGgpr6nreO8dYSLIY77QfKJYWLbAlRMbD2REc0xj2kjNYkppjibMZpCoAlMLati3XrvgsYm8LgWBtldxovhoddFR4jzZwTP2wWk/RiaB1UoU6kMdyUfvOv6jZmj01ado5dJ/1pUunceBG3//8V2XkwZo8Cmoq+O8bJ2MvKAzY8IaseaHj3cXkLnyA/dctbzJt7qYHAMieUUi0PIIvlfbik+u7O5fta2L5e6/3I6jIP/x19g4ljuCYxnho4nSOPVrN9iteJpgAmnBibduWqVs/48bEUiByLkX+cnRFeqP5Gu1BR+EI5OnyB21cj5nLdK8Yu2hGPUi6xyTw//1tOTPufCDgsUNCZnRtZWfJfvos3cqnAnoInRfWXK1t++kL0wxvXvj0nlzueqk9qzLy6sYAWBCvveKc0F5xzmzIYnX35RhtvIJB4m1+OXsHi8rtzZBl2r2b2npLk+cet+RDhifupbVLuruKhnP6wU5A5MaIcKBye3PtCs3gxqmGBjeSWv/ws9f54rbuXrdPSF7ilq8OHIFJiXn52KMg6MjIQB677qKI47seOb87w4iVkxs9hqdAHquykBXbHIlRAXvyhbQj7fBP2jN9SNMNn462lOXXLmPyknsMNbyyfRdHn87lyvQcp/uK2qLVAhxBCev6LHG2T4/Iv0VL82JboMgQjfays0x+8hEe+fUaJiRFX+jpxVG5dHxqn0szTdPGXhsMxT3dkfJWxEVosJt7xm/k/avrfK87JR3RmxQ813AjqXVkYg0jExsbbMVz/leJheZfFGEz0BUTIGN9KQBXHnIPnnAE8lyZnsO5GyoA2DN0paHaHNj2FjbpRtmuth/ZD04CGups9+wBjj4dWOd6yIxu8ayrGPezPL/awoYn2PnL9a9w+8szyP7VbuwGFY5mG7eT4rIsV/dj7z0xWOJsbL/iZWet4Zpvx8Ir2ghUCRu/MEQbgFRXk7zqcwoe6wC60b07V+v0eWvWcNK9dAAZRXl6rFttpdtfpxJ/vGFRqmpf2+gbzy+6buaZeRMahE+fuWew83fKsvCEVj+asj9q223lfDnjXpvFgntfbxDh5ytaYMosupw3fvhMhz9wfW8JRyBPCpB8QPOjzWaS4Ya3eNZVlOdcpO0W7Q/WWxlTW3bSOdazzlUZeVyZnuNmR3wlJEb35IyrmHT3Ro+FuNR2gdxND2CvtgKa8Xgqtc4RfmBcLJ/fOp8h52fR8+XDhs4c4epAXdejrrWLjci/BV5JJWG9cca2MRx5lnh3NX+uGuXmqF02aTDDL4/cK3qPNTVYNn1B5ZiBnOrne5Ga2KKE1J8u4aGaX7it//EN3zoDF5pyQfMVuVDJTe8/zJujvUdGupbVuUPeZWKLktCc3E/sFy7Q6dmt/DJpCr8et9ajjqaeqy8udKdTvcCUHzKWxEQOPdQPexzcM06zVY5AnsbKmGPmiJbdBsPQEGkJzWFMTExMTHwhJDXd26Z+7LGWW1BTwfivpmheCvpgJiuWXsVTN7qHfDqcuEf8bTIWA2q6F0flUp4e26BdqdxexbiC26iqjUW92NbQJgVfeTRlP9VTP2bzwjp3toS7jnkcI8BxPTEllWGt8Ry5NoGkzMG0uusI+V4CTu4qGs6R8lb8outmt5rbyMSaBq5FAN30mm6osJ8/T88HtvHTJdNYfu0yhie450j9svr6h0OZGGS8frBkzP6MOdYJvD6gYbh66YWEJp+raMbI4AVrairHJvRk47TfO0e/LQUatAAAGnJJREFUayo4xoFjJpyS3NA9QUEZXceo8WmxHzbYVlBTwbS9d5C2IJ6avpnO9S3bVARzyoBxaJUY5dHx/aStgtnFI7GMrySu5ChGdZoFQlrsOeTqHzfppH241o7ljhpsJ0Iz4r2D+o72nowmaHm6uPQKAE4/2Im47bt4Zt4EDtzyCQBZ8cc8dhR+eCGWZsfD47KVNWU7k5fcw70DP3Vb/3+HfkT7MflR48LoIPNXntsb20PUaY1GHDOYfOUSpLW2PJk/vzqK9HpjKbjaCAcFd2jl0NNMOIEGnARldC1tUliwepHHwWwe3D+B2j+0Z9Oapgcwtomd/bWVqDA4cHsb4d6VcnsVs4tHcmhQBRCZPwVPHKxsQ7m9qkGQxtTkYob/+WX++8bJUFJGfExgnS2BYqkVp9N5Y8w/4chTcLhaZcz+jM2ztevZcNcd9Jk7v8F+Dy+dRcaz4esszJqyvcEQjSnUjZNrbZNieJ5+X7C0aIFKTHBf6fCRFcHaKhni4sIeyNPYDCbP/mEiHd7aB+3S3HdqxEbUJ5iAk7CNvfBW1tucWliLL7MH7K+t5L9vnIylYFfIHbi9jXDvyriC27CMrySaDC7A0dFxjFt3m8cgDYeTtk0UnWMsYOA4r63WfcXMj3wYirG2lsby1NtxupzfGdEOoI4fVLOg4wcYmaffF/b87jLev2mB+7qaNGfgw9EV6bzZbyltrI4nPTy+5Y3NYPLe47/n/KMNu7MasxH1CSbgJGxGN8kST5IP3XSLz6bz1pSRmsENIp7ZG55GuAfNzanHGq02E1NSia3kaMjPHSy2kjNYHuxF37l3eHXSjgRSXY3NZXaASB8n1HRNKLmkQsCjCYm3NXjeMmNL2ftJIdX2WCYkL2lQbp02oCR0Hjh2vbm2/gwm3tb5wuKz6ay7XxvfJHFH4AEnYR9P1xOOgIOyVZ2IP2snccu2sIUo1h+pPmfxdJIOCr12lDn9CaPZrca+6zvOleQ2ndAkLEQiOOZSpueyWrKT3AMK4lSsS0d7w4rCyZqWqC07oypMOfPd+2iz3b3WGH/WTuKmbUBwNiMoo+tw4rbH+bdfqj7TQsr68M8p1nZHGTmLpzuXM5ceovbwkag2tPXp/J6FnMPaNdhzyn1yJo+kc/z3iX1F7QDIiuCwnpcSjQUUeCKUMzK40nGTNmNFjpreRErPZIdx0PegjK7DiTuasX+dTxeXyBgjpwMKFQnrv6CL7r0kV/ejW/mUxnfA86wNJt9fPM7a4cPsIuHAEVDQtabpspqU36yBF0EoNXTJC2z/cD43ZnCEiYmJiYFEpE3XJHDUlp1kbYm0iu83S78Ywj+69ALwyYE+GvBl1g6jMcuqZ0yja2JSD9dR79LNzjOTEGM2L5iYmJgYiJIQTY9hYmJiYtI0Zk3XxMTExEBMo2tiYmJiIKbRNTExMTEQ0+iamJiYGIhpdE1MTEwMJGqMrlLcrhT5SlGhFPuVCtWMRKFFKVKU4l1d50GluDPSmjyhFHFKsVTXeF4pvlKKGyOtyytKrUKpYyh1DqUKUKrpWOcIoBSrlOKYUpxTigKliEqdrihFT6WoUopVkdbiDaUor/exKcUfI63LG0HZKxEJ6QckJoB9RoAcBPkxiAWkI0jHUGsLkdY1IH8BSQIZAnIW5PJo0wrSHGQOSIaepzeDnAfJCLdWAb/zVeBygTj9dy+B4wJXRFOe6vtcDhKn/+4FchwkrDoD1eqy74cgm0FWhf3eB6lV3785SDnINdGoNVh75c+JikCeANkNUgqyHCQeZDjIEZDH9QL4hp7+ZpCdIGUgW0F+1Mixt4LcG8KMDItWvTBcBMlyWfcGyO+iTauXc30DclvAeQtFAk8I7BYoFVguEC8wXOCIwOO6sXxDT3+zwE6BMoGtAr5phWyBYwITojlPQbJBjoEEpNMIrSC3g6zV/4CDMroG5uvPQQpBVDRqDdZe+XsRu0A6g6SAbAGZq19ELchzIHEgCSADQE6CDAKx6plYRF0NYRHIIv23VTdkvwLZp2fIQpCEIDM8HFr7g1TWO9cskPeiTauH87QDqQLpFfCDpxndXQKdBVIEtgjM1Y1urcBzAnECCQIDBE4KDBKwCvxc399Rm10ksKje8RcJXBAQgR0CSdGYp/q6C5pM2QESkM5wawVpCVKgHztURteIsvoxyJxo1EoI7JW/F3G/y/JokP36RVwEiXfZ9grIb+rtvwdkmIfjpuuFdztIB5C2egbNCzLDw6F1KMjxeut+AZIXbVrrpYkF+QfIa8EUZN1o3u+yPFpgv250LwrEu2x7ReA39fbfI9CoVt1ADxF4UiA2ivPUita89CRIQDrDrRXkDyCP679DZXTDna9dQGwg3aJRayjslb8daYddfh8E0vXfp0SoctnWFZipFGWOD9DZJb0rlfr3H0U4JsJpYD4w2k9tRmgtB1rWW9cSOB+FWgFQCgvwBnARmBGkzka1ItJAK0qVOT9NaAVAxIbIp0AnYFo4dAabp5pMbCKEQmdYtCpFP+D/AQvqb4s2rfWYBHwqwoEo1Rq0vfJ3lLHOLr+7AMX6b6mX7jAwT4R5TR1QhFKlOOLhGMEScq1AARCjFD1F2Kuv6wv8Jyil4dGKUihgKdAOGC1CKKa49UsrIj5p9UAM0D3AfSFMeeqBYHVCeLQOBzKAQ0qbsioJsCrFZSIMiDKtrkwCfhegtvpEp73ys7r+Lfz/7Z15dFRVmsB/VZXKHkJCgkmAQAIkxAFFDKHDYqMeQA6LaAMNohyCTBRIu4DN6MHj1qZbR9AZWhYjmwiiwCgtLkN0mjAISBpDVIZIAkkIEJSwBLKnUvXmj1dVqS171XuV9v7OyYF6daveV/e+9717v/stUl9kG8khkP5snq5fcGibDNJ5ZBuJBnkDagpIIS189ysg/QOk3iCFmb/7T+2VTWFZP0T2YAgCaQxd9F7wsKwbQPqWLtgc7f5k88KPEvQ123QPSfBnybKRZt82WYLzZpuuRoIgCaZI4Cwr9JZgjgTBZvPCJAlqJLjfm/rUfH3OQfZc0YE0CaQakDolp4dlDQQpyuZvFUh7QIr0NlltPjPa3J8ttvEGWbuqrzr6Iyy7gZUgvWceWKcfYW5/n1mwSuQd3t2WH2FWBhts2uqRjdWVyDuKa7CxuXSywz0lazhIe80XRxlID7nh4nC7rCD1B0lC3jyrtvmb12l57b0XKiV4T4JAl0pXbn+fBP8wt70kwW6r0oUNEmww/z9SgoPmdjfNiv1fvbBPI0E6aG5303xTd1pOT1+rDp97Cfd6L7hdVpDewexN0NU/b9ZX7U7tqNFQCiySJL5u1wdURMjqITSaUmARkuTVsnanPhWyegZvltVrItIEAoHg14BQugKBQKAgonKEQCAQKIiY6QoEAoGCCKUrEAgECtJqcMQE7Syvsj18Zdqtaek9IWvnaUnW7iInCFm7wj+DrN1FThAzXYFAIFAUxZRu4cZkGrIHUDk/ValTCgQCgdfR0dwL7UYaM5yihc1f/9E960nx05MUv4SenjppF9ANjqfg2XC7Y/32aQnYm6uSRAKBQCkc7//Bm5vQHM73yLk8pnSvJwRQMnm9zRG9p07VZbS3J1GwOISSyVl2x+/q+wB1pAB4nfLVBgZS9uRwTH6ttGmA2P/Mx1Rbq5xg3YS6GSlUDG/78o/MbwK8b/wF7sUQE0rJ5I3W14nB8+mnH4EuJ8/t5xI2XYFAIFAQj810XbH80gh6FHvPJqP29iQATqf3oGT6O07v/++wT4ibJtcdTNirqGitoouM5NLswexf/O/09QlusV1BYy3LN88ABWa6jZOSqY5pezUTkVeJ6fsCj8vTGo2TkvH7wyUKkva12TbuS+8bf0cc+z643EBA3jkqpg4CIPKzMxgrKtQSr1tyetw2kk4tITbH/d/tVqWrGxyPISYUgOr+9h4TWTdiyM0cSc+Pj7rzlF2idEYYAMUPrGuxTY9eNQBohw7BdPInReRyhU+/vgA0xkdSkeTPiZXrkFOktoy/xkRNygACc+owVXU1z3rrlM6Cj+5dQ4pf881/2VjDezdu44mwn/DTyMfjPk0naXU8AMaiYo/K1BLS8it81Q6FC94z/i2hSR5KnxfPsH1AjvXYw6XjObUtibwXZPPehOI0tAfdo3Rtr0O743lnPH6NeQpdpHxPKYVblW7Bs+F2dhFbdj8+icCDx9x5ui6hDQnBGOB61l1iqCZS50Ow1p/vU3YCMP7NGfhNVFJCe4oXxgJQ8FjLDwhH4vTBHHwniwlz09AePOEp0QBIWHScOWsz+HxKc6GCN3+ZyMWpgQw+8guTA6/jp9FTMj2LOL159vioOkq3I3jL+Duh0aCLiODurUf5Y/hZu7e2D8iBF3I8ctqWrsPfPpZOUG6pfeOGBoyVNzwihzu5MmWQ9QGlBIqaF7yJ06/dyrfTV5lfBdm9tyBjGQFPX+S/h3yuvGDdmMRnT7H8lRnNB5qaMF67QtboVIoOFDspB0Hn0UVEkH7kKJMDr+MNm9Rb336Tesl+i2hO/qNEzfB+pas0blO6hRuT+eie9TheACWGahZkLCMwrwCTu07WRQo3JvPRvW/TW2evbK2y5hRQ94dedu9lJe5g3mdphE8tVFLUdpGUtYS+B+o4M1fu+5LpWW18wjOYqqrAxRLTWFFBg0l9xWAhYJk/t7861zqLfbh0PL88F2d9f9aG/aSHlrf0ce9AqyFRfxk/TaD10O25cwFozA+jIL39K6KOEL+5DIAJOWlcTfK3zhDj9M6mrt13bGTXD3e2+n2bcseSsOi4+wVtB5czRgPw3BM7nN5LylpC/OYymjxwXrcp3f6xV+zseQC7qkN585XH6Zl9AlNDg7tO1WVcyQpQL2kJyi3FWFWFZnUiE1ZMs9r+EvRB3B/7A4dQzvbTGheaqpn2+gp8aiXiD5bTVFyK//jRaovVLTCd/Ilb3hjOyAS5nmRwuQHfg8fR9Qzl4tYYxgcW4bj66Q6sSMoGIK9ff6D5Gok+VYTRTedoOn8BAO35C0SdiuQO3RL2/ZvrDd0EfRDPR7RuB/86doibJOs49eZ51exg59l48DnJ+lvdjVuUbmlmKi/032V37I1rA/lgwyR6bz/i9oqTSuC7/ziFs5MhqfnYxJAf2bw2g8RnTym/aWCzL5ldq+fpTSuI3SL74DYB1xam8pvJPyorUzvQhoRw+rVb+VPI23jDMtiC5nA+4Yfl/0tjhlO4KRmtn5Hjd64lzGYFlFY2DoC67dH4UaqCpM7oBsdz+sVQonT2x+eFXLX7t8qkJXqP5zwXjBUVRG2pYVKPFS79xU1J1Zwet80j5+4qrd0vcZ+mMySv0mMrc7co3UemHbAO9MsVtwKw5/3xxLx9xKmtK6d0b3Diz20wMOeLp0msPdVimxQ/PZ9PeUu2WyqsdC1O+nFfLsL3Zz0D/nLEelFUzk9laPpJtsQesvvMdWMtyQeXklh+w20znY6iCQzg8ylvkeQb2HZjhTGOl4vinl/cRMk4ywawvZw5/5cIQMI27/C6sQby3JOFo6xqYKqtpe9fnO9zkB9mcdWLrK8tUanewJUxBqf7xZbSB8LoEyaCIwQCgaDb43bvha3HZbtiwir7p1/tg6OoD9XS8+ELTk7pF5qqmXZzBdG7ijy2FNL4+VE56w6Meg139bJ3Xcup05J2YDEJS4/ZLSmCC3x5Y9RAANV33i1hqI5O+rUPjmLsk8dYHW3/RC401DDrxCISM4pVc9vRRUZyaeYgQrTNvfrGtYEEF/iqIo8t0pjhnF8srx5aWwIPGvALANfSUvG/YSLwY3XdHq+M6EnJdHv3puWXRjAi+Jx1tQny+M/JX0SfBvU2BDWH80k43Pw6+4dhpPip7+vcOCnZOq6usGxEJybNp0ecnKAruNyA7373bPh1SelqfHwwjRpKb312m20eydzX4o5wX59gTqxcxwjjYqL+C48oXm3PULa8+qbLZe5LZ6e73EGNWXWEzUGTAPhjB/xjlaC1fi001DDvxzSiZhQoblZoK4hj8+5JxK5yvRxVkqKFPjYmhZaxBlFkwqtXhnDoY3U2Ui396iro6Ksdv+HruxKZZ/bGANh1405Vxr+95DYYADhXFkGCwrby9gbHnB63DWSTvuzhUn8HmiYJ7bGTSE2d92voktLV9grnrR3rWrTXaXx80CbEs+aDtSTomzcnrhtl222NZLLb9cx7YT0p9YsJ26pMyKJFjuu1AUQpckb30Fa/zjqxiKgZyoba6nqGgp8fRUv7AVA439nZ/EJTNdpGRcXq9jj3q/zwN0omzjbVsWfRRMJfLCdnaPMSqNpUz7m6XkCNGiK3i9//XfYcUctdrDVKDNXUS1qidBCmk3Xb9gE5sDOHQkMNT01Ow1RY3GnF69HgCNOooaz5YC0DfQLsjicfXApAj6MB5pmQOljkSMwo9toZgSva6lc1fs/FrTF8OHwTvXQWXxVnl6tpr5s9LpQVrVvTUr+ebarjqclpaAtPAn3tPjOz8HdoZ9XhzUrXm1mQsYyg3FJOr+7D2Xu22L030CeA//hyCxkPLe106kePKd3aB0fxSOY+u5kYWGLvrwBwZYy6Pq+mBtnnpiWbZ2lmKn/9/btKitQmLfUrtP17PElYYF2bHgr6Gslr0kwmvXaNOEM6INvwsm7EsPvxSXZtLj9dbw2gUINrnyWwe9hGl2Pd38eXu3d9R4NJz+zQHdg+5NYM3MWuA81BCd8sTEY6flIJkV2i6xVOny8aSA87jLf6P9uOf2BeAcaqKhJfDiauuvkaAdBptCTog5i5MZv3V07rlI2/S0rXVHmDtOeXseyFnVYH41fHfgJA3vD+TrbG+E8eQyNB7Vp5rjOul7PAUouVhdxL4qH5DN7c+vKgMcrAxECDMgK1gaXixtgnj7m0jbfn93gSzeoIRsYstjtW3V9jFxml1Ni2RfFrqYSfgiHrKwEYeWyxvEnmkBvk5vxku9ezQ79j995F9FlQrsiD7f7YH1wqXAA/jd5mc9e+jWNQwoSgVHXdlHx8WHbLZ9YIULWvVUeWXxpBbuZI6/hbVmLGomKGrJcdkOONj1H8QHMmwvTQct4N1XbKaa9LSldqaCB0+7cUrogGs9J1dNC2ZeCQcsZGnOXFSNe+sJ52SrZFWxCM5nDLGzrlz4xmQXKOApK0Tvkzo6lOamT8v8gzFUcvBZAv4n7rfaiPlIfz/KZk2Zd3pXK+pb77j2Nbd0MaM5zG+70nCtFCaWYqLz2wi6/H32r1wQ0u0BC+pe0ZS4I+iA+Hb2K534w223YFdwWUXDbWMHbHMwwuPu+RcNbO0ta9pzTfXY1tccZqSUOamJVEnC7dLSH2bjEvvL/vbuJmVrhUtLa42jHMbTBYjepJq6+olu7PlssZo5m/YL9qbmK2VSEWzmyfHBfH+xOZegmAkmGfyDvtK9Uz31xPCOD7lK3W17fnzuWWwjrV5LFgCeSZF3KIlwPk63VPwXindpXzU60POiXx6deXoqX9+Hb6KqfcIK2RVjbO+hCxoKnXkZh5kqZumnLRE1zOGM1DMfvd8l0376shtKTjARQiOEIgEAgUxC0z3QErj/LuyHHMG9rx9PrZVcNIeFR2G1F0x90hIYQuMtKaaf+5J3a4TIKhFJqQYPY8tqrdobO2/oTeSu+3/NEc9mxO39awBMck+DdvjH1zRQ588b8qUfvgKII+z28OoMlwHXDi6YCDxvhIs7td+2e5yy+N4NS6oS5Dlb3SU0TFZCy/S/+708rxzl5l5D44ys7E4FiN42qyyam6zNRBJ/kmdlSHC+26zXvhXFkEuYMN7YqttjhGZ1cN429ltxGO8ukS66ObMP32DuvrCps0da4oNNSw68adsv9jFxyj20IbEkJNygD8NZ2/XQoNNar1q6MTf4NkYM31IehqDKomPnIVHGMb+JB1I4YdhqnszFzlMk0heG/AwaG/jiLMS3JDeDt/K7uN2aHf2W1Qro7OIyvzZ3ZfbfZecazG4UhXKuG4Tek6Vg4I0Zpcpnu7bKxhzhfLABi89JgqigHMLiDT298+/fQ8/CaWIvs+es7/sWnEIA6+k0VbpXhsudBUTZWp2VI0J1/54AgL1soCZq+FYoOBA/cORPpFPZclAEwSpw29iddft5YOsiU9tJz0VvpdrYADy9ha/HRd5YDWNnXHPH7qED61kPTseXbBJGAe/51bWvhUM7ZBKYGHOxcS7lY/XdvKAZdmDnIZ+DB2xzMkZso3oFcufboh015fQfSeM9bXfRrKvW42pjbGK12rYKFWwIFlbM88LZtCHCP9FmQso2f2iW6ZPrU7YhuU0tk+d6vSta0cEL1LYsLJNKc2g4vPd5vd1LhP0xm0UzaFBFyt86qHhKXKhe9Ng5ykWlR7bR1JwlhRwf8sSOX7Nf1aXTraYqnGEPO8hPHqRQ8KKOOTd4YJc5vvm+hTRZx9ahBvz7TPE2Fb5cSbCgR0Bxwrh7SGZfx7vyV7AmmaJFnhqpV7oTWMFRUuK5Cq5S9oCeQw6tvvoT/Eply42gp3QsE0ACq3yzZTnUGSZzgNDV4zqy1/ZjQLZzW741grh1Sqt4HmiHT8JBdfTmbCipB2JT25eVVezkedVCZHgKmqyq6IaNFrsl+xbZCOt1ZkaS8LZ+1nW41sP41RIfmRY+WQ1rC4OdpuAnd1VfGrKUxpCeToCGooWt/iCpKyljgdtyQxD9/bbLj3tiVldVKj3dK9sD6a0O3fep2cvvuPUxeQQtJw5352pF++umEFfUZcsvN/7+4VWUBOk7ouSd3MR7aVQ5TmV6N0uwtN5y8Q+5JnajN5mojDeuJorhTg+7OeAXjnrnrA3lxiO+7hqDhXs2OIO9/cp8EFvi4rsnQn0srGEXHYOypIqIEIjhAIBAIFETNdgdsI33yU8M1qS/HPhRo2T7fT0MCc/EcJC5Tto3Xbown/FfsVC6UrEAg8irHyBlEzmiM8vaWqsloI84JAIBAoiEaSuuseqEAgEHQ/xExXIBAIFEQoXYFAIFAQoXQFAoFAQYTSFQgEAgURSlcgEAgURChdgUAgUJD/B7UCzbm601T5AAAAAElFTkSuQmCC\n",
       "text/plain": [
        "<Figure size 432x288 with 32 Axes>"
       ]
@@ -1125,7 +1065,7 @@
     "images = data[\"image\"]\n",
     "labels = data[\"label\"]\n",
     "\n",
-    "output =model.predict(Tensor(data['image']))\n",
+    "output = model.predict(Tensor(data['image']))\n",
     "prb = output.asnumpy()\n",
     "pred = np.argmax(output.asnumpy(), axis=1)\n",
     "err_num = []\n",
@@ -1150,18 +1090,18 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "构建一个概率分析的饼图函数。\n",
+    "构建一个概率分析的饼图函数，本例展示了当前`batch`中的前两张图片的分析饼图。\n",
     "\n",
     "备注：`prb`为上一段代码中，存储这组数对应的数字概率。"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 17,
    "metadata": {
     "ExecuteTime": {
-     "end_time": "2020-09-01T09:39:54.582155Z",
-     "start_time": "2020-09-01T09:39:54.412242Z"
+     "end_time": "2020-09-04T06:46:59.943697Z",
+     "start_time": "2020-09-04T06:46:59.803412Z"
     }
    },
    "outputs": [
@@ -1170,13 +1110,13 @@
      "output_type": "stream",
      "text": [
       "Figure 1 probability of corresponding numbers [0-9]:\n",
-      " [-3.4309022  -0.5834117   0.01877569  6.612137   -2.295098    2.562793\n",
-      " -4.9184275  -0.60120285  0.77347684  2.361938  ]\n"
+      " [10.731268   -8.178983    0.7688376  -1.5208994  -3.4331348  -0.6836271\n",
+      "  3.7032425  -2.7914028   0.43636245 -0.42814386]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -1189,13 +1129,13 @@
      "output_type": "stream",
      "text": [
       "Figure 2 probability of corresponding numbers [0-9]:\n",
-      " [-4.255555  -2.4440086 -3.5128884  7.8171043 -3.3812468  6.995471\n",
-      " -4.468177  -2.909104   2.3818579  4.859018 ]\n"
+      " [-5.470294    8.598144   -0.29099795 -1.5832896  -0.88322777 -1.8221556\n",
+      " -0.637848   -0.71524227  2.496806   -0.6640963 ]\n"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
diff --git a/tutorials/notebook/synchronization_training_and_evaluation.ipynb b/tutorials/notebook/synchronization_training_and_evaluation.ipynb
index 236ae433c882d620ead10a0247dc321bab8122d3..80f857391986c557ac75db948419f81a400a3473 100644
--- a/tutorials/notebook/synchronization_training_and_evaluation.ipynb
+++ b/tutorials/notebook/synchronization_training_and_evaluation.ipynb
@@ -371,7 +371,7 @@
     "    eval_data = create_dataset(eval_data_path, repeat_size=repeat_size)\n",
     "    \n",
     "    # define the loss function\n",
-    "    net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')\n",
+    "    net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
     "    # define the optimizer\n",
     "    net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)\n",
     "    config_ck = CheckpointConfig(save_checkpoint_steps=eval_per_epoch*1875, keep_checkpoint_max=15)\n",
diff --git a/tutorials/source_en/advanced_use/computer_vision_application.md b/tutorials/source_en/advanced_use/computer_vision_application.md
index 13fa54ac4c57c24d0cf5c8becf909ba0bc369355..f340d987782d99ef426d62714fd9b23a8a166887 100644
--- a/tutorials/source_en/advanced_use/computer_vision_application.md
+++ b/tutorials/source_en/advanced_use/computer_vision_application.md
@@ -167,7 +167,7 @@ An example of the code for defining the loss function and optimizer in MindSpore
 
 ```python
 # loss function definition
-ls = SoftmaxCrossEntropyWithLogits(sparse=True, is_grad=False, reduction="mean")
+ls = SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
 
 # optimization definition
 opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01, 0.9)
diff --git a/tutorials/source_en/advanced_use/debugging_in_pynative_mode.md b/tutorials/source_en/advanced_use/debugging_in_pynative_mode.md
index 877b07e0a6dcc8e7980a883927f5d1f235bcd213..42c3fbe92887490eb7116526de3f1d3a91a6bd47 100644
--- a/tutorials/source_en/advanced_use/debugging_in_pynative_mode.md
+++ b/tutorials/source_en/advanced_use/debugging_in_pynative_mode.md
@@ -361,7 +361,7 @@ class GradWrap(nn.Cell):
 
 net = LeNet5()
 optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.1, 0.9)
-criterion = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
+criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
 net_with_criterion = WithLossCell(net, criterion)
 train_network = GradWrap(net_with_criterion)
 train_network.set_train()
diff --git a/tutorials/source_en/advanced_use/differential_privacy.md b/tutorials/source_en/advanced_use/differential_privacy.md
index 33635e67bdc654970158e0bafa8fe4184b0ee77d..746f969dbbcd4a8bb517f393f07af02b97734595 100644
--- a/tutorials/source_en/advanced_use/differential_privacy.md
+++ b/tutorials/source_en/advanced_use/differential_privacy.md
@@ -233,7 +233,7 @@ Load the LeNet network, define the loss function, configure the checkpoint param
 
 ```python
 network = LeNet5()
-net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
 config_ck = CheckpointConfig(save_checkpoint_steps=cfg.save_checkpoint_steps,
                              keep_checkpoint_max=cfg.keep_checkpoint_max)
 ckpoint_cb = ModelCheckpoint(prefix="checkpoint_lenet",
diff --git a/tutorials/source_en/advanced_use/distributed_training_ascend.md b/tutorials/source_en/advanced_use/distributed_training_ascend.md
index 6cfb3db2427102e17d88aa4ff1c02c56124ba1fb..79e37f45fee988a6ea9214db2fabb8f8fe5a9c8b 100644
--- a/tutorials/source_en/advanced_use/distributed_training_ascend.md
+++ b/tutorials/source_en/advanced_use/distributed_training_ascend.md
@@ -215,7 +215,7 @@ The `Momentum` optimizer is used as the parameter update tool. The definition is
 `context.set_auto_parallel_context` is an API for users to set parallel training parameters and must be called before the initialization of networks. The related parameters are as follows:
 
 - `parallel_mode`: parallel distributed mode. The default value is `ParallelMode.STAND_ALONE`. The options are `ParallelMode.DATA_PARALLEL` and `ParallelMode.AUTO_PARALLEL`.
-- `mirror_mean`: During backward computation, the framework collects gradients of parameters in data parallel mode across multiple hosts, obtains the global gradient value, and transfers the global gradient value to the optimizer for update. The default value is `False`, which indicates that the `allreduce_sum` operation is applied. The value `True` indicates that the `allreduce_mean` operation is applied.
+- `gradients_mean`: During backward computation, the framework collects gradients of parameters in data parallel mode across multiple hosts, obtains the global gradient value, and transfers the global gradient value to the optimizer for update. The default value is `False`, which indicates that the `allreduce_sum` operation is applied. The value `True` indicates that the `allreduce_mean` operation is applied.
 - `enable_parallel_optimizer`: a developing feature. Whether to use optimizer model parallel, which improves performance by distributing the parameters to be updated to each worker, and applying Broadcast among workers to share updated parameters. This feature can be used only in data parallel mode and when the number of parameters is larger than the number of devices.
 
 > You are advised to set `device_num` and `global_rank` to their default values. The framework calls the HCCL API to obtain the values.
@@ -228,7 +228,8 @@ In the following sample code, the automatic parallel mode is specified. To switc
 from mindspore import context
 from mindspore.nn.optim.momentum import Momentum
 from mindspore.train.callback import LossMonitor
-from mindspore.train.model import Model, ParallelMode
+from mindspore.train.model import Model
+from mindspore.context import ParallelMode
 from resnet import resnet50
 
 device_id = int(os.getenv('DEVICE_ID'))
@@ -236,7 +237,7 @@ context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 context.set_context(device_id=device_id) # set device_id
 
 def test_train_cifar(epoch_size=10):
-    context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL, mirror_mean=True)
+    context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL, gradients_mean=True)
     loss_cb = LossMonitor()
     dataset = create_dataset(data_path)
     batch_size = 32
diff --git a/tutorials/source_en/advanced_use/model_security.md b/tutorials/source_en/advanced_use/model_security.md
index 3075c95afc17ce627519c7fc729e97e0ff48376d..1af2ab041609546249ad740879d8d9ac3e2ab636 100644
--- a/tutorials/source_en/advanced_use/model_security.md
+++ b/tutorials/source_en/advanced_use/model_security.md
@@ -185,7 +185,7 @@ The LeNet model is used as an example. You can also create and train your own mo
                                       batch_size=batch_size, repeat_size=1,
                                       sparse=False)
     net = LeNet5()
-    loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=False)
+    loss = SoftmaxCrossEntropyWithLogits(sparse=False)
     opt = nn.Momentum(net.trainable_params(), 0.01, 0.09)
     model = Model(net, loss, opt, metrics=None)
     model.train(10, ds_train, callbacks=[LossMonitor()],
diff --git a/tutorials/source_en/advanced_use/network_migration.md b/tutorials/source_en/advanced_use/network_migration.md
index 0e5e4fd8845dbd76f498d6963f1ef13718b063e3..71511c4356005ffbe0d23aa0bff5b82cf747b451 100644
--- a/tutorials/source_en/advanced_use/network_migration.md
+++ b/tutorials/source_en/advanced_use/network_migration.md
@@ -223,7 +223,7 @@ The ResNet-50 network migration and training on the Ascend 910 is used as an exa
    After the network is defined, the loss function and optimizer need to be defined accordingly.
 
    ```python
-   loss = SoftmaxCrossEntropyWithLogits(sparse=True)
+   loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
    opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), lr, config.momentum, config.weight_decay, config.loss_scale)
    ```
 
diff --git a/tutorials/source_en/advanced_use/nlp_application.md b/tutorials/source_en/advanced_use/nlp_application.md
index e42856478bac7fa3fe53405003e1e517bab00fca..f33da2ffbbb114b44873cf6da67f7ee4cdc0832d 100644
--- a/tutorials/source_en/advanced_use/nlp_application.md
+++ b/tutorials/source_en/advanced_use/nlp_application.md
@@ -193,7 +193,7 @@ if args.pre_trained:
 The sample code for defining the optimizer and loss function is as follows:
 
 ```python
-loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
+loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
 opt = nn.Momentum(network.trainable_params(), cfg.learning_rate, cfg.momentum)
 loss_cb = LossMonitor()
 ```
diff --git a/tutorials/source_en/advanced_use/summary_record.md b/tutorials/source_en/advanced_use/summary_record.md
index c8e52b400e6defdbb4dab5428947cc0c8dea22a9..eb80a56643dbd343b8e64c4b30cda2ffc8887975 100644
--- a/tutorials/source_en/advanced_use/summary_record.md
+++ b/tutorials/source_en/advanced_use/summary_record.md
@@ -106,7 +106,7 @@ class AlexNet(nn.Cell):
 context.set_context(mode=context.GRAPH_MODE)
 
 network = AlexNet(num_classes=10)
-loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
 lr = Tensor(0.1)
 opt = nn.Momentum(network.trainable_params(), lr, momentum=0.9)
 model = Model(network, loss, opt)
diff --git a/tutorials/source_en/quick_start/quick_start.md b/tutorials/source_en/quick_start/quick_start.md
index 78cbaac01ff64442f7112b3101d169710d0266c0..bd409bdc4763541799d9de0fe386b9cedf3b6c1e 100644
--- a/tutorials/source_en/quick_start/quick_start.md
+++ b/tutorials/source_en/quick_start/quick_start.md
@@ -202,20 +202,20 @@ Define each layer of a neural network in the `__init__` method in advance, and t
 
 ```python
 import mindspore.nn as nn
+from mindspore.common.initializer import Normal
 
 class LeNet5(nn.Cell):
     """
     Lenet network structure
     """
     #define the operator required
-    def __init__(self, num_class=10, channel=1):
+    def __init__(self, num_class=10, num_channel=1):
         super(LeNet5, self).__init__()
-        self.num_class = num_class
-        self.conv1 = nn.Conv2d(channel, 6, 5, pad_mode='valid')
+        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
         self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
-        self.fc1 = nn.Dense(16 * 5 * 5, 120)
-        self.fc2 = nn.Dense(120, 84)
-        self.fc3 = nn.Dense(84, self.num_class)
+        self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
+        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
+        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
         self.relu = nn.ReLU()
         self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
         self.flatten = nn.Flatten()
@@ -256,7 +256,7 @@ Call the defined loss function in the `__main__` function.
 if __name__ == "__main__":
     ...
     #define the loss function
-    net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')
+    net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
     ...
 ```
 
@@ -346,16 +346,20 @@ The following is an example of loss values output during training:
 
 ```bash
 ...
-epoch: 1 step: 262, loss is 1.9212162
-epoch: 1 step: 263, loss is 1.8498616
-epoch: 1 step: 264, loss is 1.7990671
-epoch: 1 step: 265, loss is 1.9492403
-epoch: 1 step: 266, loss is 2.0305142
-epoch: 1 step: 267, loss is 2.0657792
-epoch: 1 step: 268, loss is 1.9582214
-epoch: 1 step: 269, loss is 0.9459006
-epoch: 1 step: 270, loss is 0.8167224
-epoch: 1 step: 271, loss is 0.7432692
+epoch: 1 step: 1, loss is 2.3025916
+epoch: 1 step: 2, loss is 2.302577
+epoch: 1 step: 3, loss is 2.3023994
+epoch: 1 step: 4, loss is 2.303059
+epoch: 1 step: 5, loss is 2.3025753
+epoch: 1 step: 6, loss is 2.3027692
+epoch: 1 step: 7, loss is 2.3026521
+epoch: 1 step: 8, loss is 2.3014607
+...
+epoch: 1 step: 1871, loss is 0.048939988
+epoch: 1 step: 1872, loss is 0.028885357
+epoch: 1 step: 1873, loss is 0.09475248
+epoch: 1 step: 1874, loss is 0.046067055
+epoch: 1 step: 1875, loss is 0.12366105
 ...
 ```
 
@@ -411,7 +415,7 @@ Command output similar to the following is displayed:
 
 ```
 ============== Starting Testing ==============
-============== Accuracy:{'Accuracy': 0.9742588141025641} ==============
+============== Accuracy:{'Accuracy': 0.9663477564102564} ==============
 ```
 
-The model accuracy data is displayed in the output content. In the example, the accuracy reaches 97.4%, indicating a good model quality.
+The model accuracy data is displayed in the output content. In the example, the accuracy reaches 96.6%, indicating a good model quality. The model accuracy will be improved with more iterations `epoch_size`.
diff --git a/tutorials/source_en/quick_start/quick_video.md b/tutorials/source_en/quick_start/quick_video.md
index d31b4343a77aa73dc1dff04577c1d327f6c45997..84d8945edbec02c048132e5e1936f63d19af56c8 100644
--- a/tutorials/source_en/quick_start/quick_video.md
+++ b/tutorials/source_en/quick_start/quick_video.md
@@ -137,6 +137,30 @@ Provides video tutorials from installation to try-on, helping you quickly use Mi
                     </svg>
                </a>
           </div>
+          <div
+               class="video-item-wraper" style="width: 33.3%;display: flex;justify-content: center;align-items: center;padding: 10px;box-sizing: border-box;">
+               <a href="https://www.mindspore.cn/tutorial/en/master/quick_start/quick_video/loading_the_dataset_and_converting_data_format.html" target="_blank"
+                    style="position: relative;">
+                    <img src="https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/teaching_video/cover/%E6%89%8B%E6%8A%8A%E6%89%8B%E7%B3%BB%E5%88%97/Load%20Dataset%E6%B1%87%E6%80%BB%E9%A1%B5.png"
+                         style="max-width: 100%;width: 400px;">
+                    <svg style="position: absolute;left: 50%;top: 50%;width: 30px;height: 30px;transform: translate(-50%, -50%);"
+                         data-v-1534670d="" id="图层_1" data-name="图层 1" xmlns="http://www.w3.org/2000/svg"
+                         viewBox="0 0 30 30" class="icon-position">
+                         <title data-v-1534670d="">play</title>
+                         <g data-v-1534670d="" style="opacity: 0.3;">
+                              <path data-v-1534670d="" d="M301.21,376.21a15,15,0,1,1-15,15A15,15,0,0,1,301.21,376.21Z"
+                                   transform="translate(-286.21 -376.21)"
+                                   style="fill: rgb(255, 255, 255); fill-rule: evenodd;"></path>
+                         </g>
+                         <path data-v-1534670d=""
+                              d="M301.21,377.21a14,14,0,1,1-14,14,14,14,0,0,1,14-14m0-1a15,15,0,1,0,15,15,15,15,0,0,0-15-15Z"
+                              transform="translate(-286.21 -376.21)" style="fill: rgb(255, 255, 255);"></path>
+                         <path data-v-1534670d=""
+                              d="M308.15,392.32l-9.39,5.28c-.72.41-1.31.06-1.31-.76v-10.5c0-.83.58-1.17,1.31-.76l9.39,5.28C308.87,391.25,308.87,391.91,308.15,392.32Z"
+                              transform="translate(-286.21 -376.21)" style="fill: rgb(255, 255, 255);"></path>
+                    </svg>
+               </a>
+          </div>
           <div
                class="video-item-wraper" style="width: 33.3%;display: flex;justify-content: center;align-items: center;padding: 10px;box-sizing: border-box;">
                <a href="https://www.mindspore.cn/tutorial/en/master/quick_start/quick_video/saving_and_loading_model_parameters.html" target="_blank"
diff --git a/tutorials/source_en/quick_start/quick_video/loading_the_dataset_and_converting_data_format.md b/tutorials/source_en/quick_start/quick_video/loading_the_dataset_and_converting_data_format.md
new file mode 100644
index 0000000000000000000000000000000000000000..697ce4f2eca0b68f37da5b854955631f234aaf0f
--- /dev/null
+++ b/tutorials/source_en/quick_start/quick_video/loading_the_dataset_and_converting_data_format.md
@@ -0,0 +1,14 @@
+# Loading the Dataset and Converting Data Format
+
+[comment]: <> (This document contains Hands-on Tutorial Series. Gitee does not support display. Please check tutorials on the official website)
+
+<video id="video5" autoplay controls width="1200px" height="600px" poster="https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/teaching_video/cover/%E6%89%8B%E6%8A%8A%E6%89%8B%E7%B3%BB%E5%88%97/Load%20Dataset%E8%AF%A6%E6%83%85%E9%A1%B5.png">
+<source id="mp45" src="https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/teaching_video/video/Load%20Dataset%20and%20Convert%20Format.mp4" type="video/mp4">
+</video>
+
+**See More**：
+<https://www.mindspore.cn/tutorial/en/master/use/data_preparation/loading_the_datasets.html>
+
+<https://www.mindspore.cn/tutorial/en/master/use/data_preparation/converting_datasets.html>
+
+              
\ No newline at end of file
diff --git a/tutorials/source_en/use/multi_platform_inference.md b/tutorials/source_en/use/multi_platform_inference.md
index 704b96d460f744f09f9ff57645f44865ecc4eb12..f18a61689547df6ab7f969bd64f83a73ab427022 100644
--- a/tutorials/source_en/use/multi_platform_inference.md
+++ b/tutorials/source_en/use/multi_platform_inference.md
@@ -63,7 +63,7 @@ MindSpore supports the following inference scenarios based on the hardware platf
 
     ```python
     network = LeNet5(cfg.num_classes)
-    net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
     net_opt = nn.Momentum(network.trainable_params(), cfg.lr, cfg.momentum)
     model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
 
@@ -86,7 +86,7 @@ MindSpore supports the following inference scenarios based on the hardware platf
 
     ```python
     network = LeNet5(cfg.num_classes)
-    net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
     net_opt = nn.Momentum(network.trainable_params(), cfg.lr, cfg.momentum)
     model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
 
diff --git a/tutorials/source_zh_cn/advanced_use/computer_vision_application.md b/tutorials/source_zh_cn/advanced_use/computer_vision_application.md
index b40d13a7fa7902d980e836074462d76ae3732081..9d3f271063bac46d059708c22a9a7c0ca062e9d7 100644
--- a/tutorials/source_zh_cn/advanced_use/computer_vision_application.md
+++ b/tutorials/source_zh_cn/advanced_use/computer_vision_application.md
@@ -170,7 +170,7 @@ MindSpore中定义损失函数和优化器的代码样例如下：
 
 ```python
 # loss function definition
-ls = SoftmaxCrossEntropyWithLogits(sparse=True, is_grad=False, reduction="mean")
+ls = SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
 
 # optimization definition
 opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01, 0.9)
diff --git a/tutorials/source_zh_cn/advanced_use/debugging_in_pynative_mode.md b/tutorials/source_zh_cn/advanced_use/debugging_in_pynative_mode.md
index a8c87f9ba8f6df44d9f5c4193b4d2b14ba1db147..fd4a8fed7eb57116f43100741ea9018d69b202b8 100644
--- a/tutorials/source_zh_cn/advanced_use/debugging_in_pynative_mode.md
+++ b/tutorials/source_zh_cn/advanced_use/debugging_in_pynative_mode.md
@@ -363,7 +363,7 @@ class GradWrap(nn.Cell):
 
 net = LeNet5()
 optimizer = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.1, 0.9)
-criterion = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
+criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
 net_with_criterion = WithLossCell(net, criterion)
 train_network = GradWrap(net_with_criterion)
 train_network.set_train()
diff --git a/tutorials/source_zh_cn/advanced_use/differential_privacy.md b/tutorials/source_zh_cn/advanced_use/differential_privacy.md
index 0f09b27154658ff26c1f03bb73613eb28f4f7ca3..7e9dac091d64dedfc3c694701871173bd858fc3e 100644
--- a/tutorials/source_zh_cn/advanced_use/differential_privacy.md
+++ b/tutorials/source_zh_cn/advanced_use/differential_privacy.md
@@ -233,7 +233,7 @@ class LeNet5(nn.Cell):
 
 ```python
 network = LeNet5()
-net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
 config_ck = CheckpointConfig(save_checkpoint_steps=cfg.save_checkpoint_steps,
                              keep_checkpoint_max=cfg.keep_checkpoint_max)
 ckpoint_cb = ModelCheckpoint(prefix="checkpoint_lenet",
diff --git a/tutorials/source_zh_cn/advanced_use/distributed_training_ascend.md b/tutorials/source_zh_cn/advanced_use/distributed_training_ascend.md
index d02d36a460a235f4c29c86c93503a6957e7f60ca..a0e4e8864f3e066b45c4c65d57db7743c0b01055 100644
--- a/tutorials/source_zh_cn/advanced_use/distributed_training_ascend.md
+++ b/tutorials/source_zh_cn/advanced_use/distributed_training_ascend.md
@@ -218,7 +218,7 @@ class SoftmaxCrossEntropyExpand(nn.Cell):
 `context.set_auto_parallel_context`是配置并行训练参数的接口，必须在初始化网络之前调用。主要参数包括：
 
 - `parallel_mode`：分布式并行模式，默认为单机模式`ParallelMode.STAND_ALONE`。可选数据并行`ParallelMode.DATA_PARALLEL`及自动并行`ParallelMode.AUTO_PARALLEL`。
-- `mirror_mean`：反向计算时，框架内部会将数据并行参数分散在多台机器的梯度值进行收集，得到全局梯度值后再传入优化器中更新。默认值为`False`，设置为True对应`allreduce_mean`操作，False对应`allreduce_sum`操作。
+- `gradients_mean`：反向计算时，框架内部会将数据并行参数分散在多台机器的梯度值进行收集，得到全局梯度值后再传入优化器中更新。默认值为`False`，设置为True对应`allreduce_mean`操作，False对应`allreduce_sum`操作。
 - `enable_parallel_optimizer`：开发中特性。打开优化器模型并行开关，通过拆分权重到各卡分别进行更新再同步的方式以提升性能。该参数目前只在数据并行模式和参数量大于机器数时有效，支持`Lamb`和`Adam`优化器。
 
 > `device_num`和`global_rank`建议采用默认值，框架内会调用HCCL接口获取。
@@ -231,7 +231,8 @@ class SoftmaxCrossEntropyExpand(nn.Cell):
 from mindspore import context
 from mindspore.nn.optim.momentum import Momentum
 from mindspore.train.callback import LossMonitor
-from mindspore.train.model import Model, ParallelMode
+from mindspore.train.model import Model
+from mindspore.context import ParallelMode
 from resnet import resnet50
 
 device_id = int(os.getenv('DEVICE_ID'))
@@ -239,7 +240,7 @@ context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
 context.set_context(device_id=device_id) # set device_id
 
 def test_train_cifar(epoch_size=10):
-    context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL, mirror_mean=True)
+    context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL, gradients_mean=True)
     loss_cb = LossMonitor()
     dataset = create_dataset(data_path)
     batch_size = 32
diff --git a/tutorials/source_zh_cn/advanced_use/gradient_accumulation.md b/tutorials/source_zh_cn/advanced_use/gradient_accumulation.md
index 574ed6e6c80be76174a9773e89034993aad1f645..f982312405044dbad3b7ba9457a80a629029dee4 100644
--- a/tutorials/source_zh_cn/advanced_use/gradient_accumulation.md
+++ b/tutorials/source_zh_cn/advanced_use/gradient_accumulation.md
@@ -218,7 +218,7 @@ if __name__ == "__main__":
     ds_train = create_dataset(os.path.join(args.data_path, "train"), 32)
 
     network = LeNet5(10)
-    net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
     net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
     model = GradientAccumulation(network, net_loss, net_opt)
 
diff --git a/tutorials/source_zh_cn/advanced_use/mobilenetv2_incremental_learn.md b/tutorials/source_zh_cn/advanced_use/mobilenetv2_incremental_learn.md
new file mode 100644
index 0000000000000000000000000000000000000000..f47fd4ad6c02d09fabaa6769ba528a9404a3657e
--- /dev/null
+++ b/tutorials/source_zh_cn/advanced_use/mobilenetv2_incremental_learn.md
@@ -0,0 +1,396 @@
+# MobileNetV2 增量学习
+`CPU` `Ascend` `GPU` `模型开发` `中级` `高级`
+
+<!-- TOC -->
+
+- [增量学习](#增量学习)
+  - [概述](#概述)
+  - [任务描述及准备](#任务描述及准备)
+    - [环境配置](#环境配置)
+    - [下载代码](#下载代码)
+    - [准备预训练模型](#准备预训练模型)
+    - [准备数据](#准备数据)
+  - [预训练模型加载代码详解](#预训练模型加载代码详解)
+  - [参数简介](#参数简介)
+    - [运行Python文件](#运行python文件)
+    - [运行Shell脚本](#运行shell脚本)
+  - [加载增量学习训练](#加载增量学习训练)
+    - [CPU加载训练](#cpu加载训练)
+    - [GPU加载训练](#gpu加载训练)
+    - [Ascend加载训练](#ascend加载训练)
+    - [增量学习训练结果](#增量学习训练结果)
+  - [验证增量学习训练模型](#验证增量学习训练模型)
+    - [验证模型](#验证模型)
+    - [验证结果](#验证结果)
+<!-- /TOC -->
+
+<a href="https://gitee.com/mindspore/docs/blob/master/tutorials/source_zh_cn/advanced_use/mobilenetv2_incremental_learn.md" target="_blank"><img src="../_static/logo_source.png"></a>&nbsp;&nbsp;
+
+## 概述
+
+计算机视觉任务中，从头开始训练一个网络耗时巨大，需要大量计算能力。预训练模型选择的常见的OpenImage、ImageNet、VOC、COCO等公开大型数据集，规模达到几十万甚至超过上百万张。大部分任务数据规模较大，训练网络模型时，如果不使用预训练模型，从头开始训练网络，需要消耗大量的时间与计算能力，模型容易陷入局部极小值和过拟合。因此大部分任务都会选择预训练模型，在其上做增量学习。  
+
+MindSpore是一个多元化的机器学习框架。既可以在手机等端侧和PC等设备上运行，也可以在云上的服务器集群上运行。目前MobileNetV2支持在Windows系统中使用单核CPU做增量学习，在EulerOS、Ubuntu系统中使用单个或者多个Ascend AI处理器或GPU中做增量学习，本教程将会介绍如何在不同系统与处理器下的MindSpore框架中做增量学习的训练与验证。
+
+目前，Window上暂只支持支持CPU，Ubuntu与EulerOS上支持CPU、GPU与Ascend AI处理器三种处理器。 
+
+>你可以在这里找到完整可运行的样例代码：https://gitee.com/mindspore/mindspore/tree/master/model_zoo/official/cv/mobilenetv2
+
+## 任务描述及准备
+
+### 环境配置
+
+若在本地环境运行，需要安装MindSpore框架，配置CPU、GPU或Ascend AI处理器。若在华为云环境上运行，不需要安装MindSpore框架，不需要配置Ascend AI处理器、CPU与GPU，可以跳过本小节。
+
+1. 安装MindSpore框架
+    在EulerOS、Ubuntu或者Windows等系统上需要根据系统和处理器架构[安装对应版本MindSpore框架](https://www.mindspore.cn/install)。
+
+2. 配置CPU环境  
+    使用CPU时，在代码中，需要在调用CPU开始训练或测试前，按照如下代码设置：
+
+    ```Python
+    if config.platform == "CPU":
+        context.set_context(mode=context.GRAPH_MODE, device_target=config.platform, \
+            save_graphs=False)
+    ```
+
+3. 配置GPU环境  
+    使用GPU时，在代码中，需要在调用GPU开始训练或测试前，按照如下代码设置：
+
+    ```Python
+    elif config.platform == "GPU":
+        context.set_context(mode=context.GRAPH_MODE, device_target=config.platform, \
+            save_graphs=False)
+        init("nccl")
+        context.set_auto_parallel_context(device_num=get_group_size(),
+                                          parallel_mode=ParallelMode.DATA_PARALLEL,
+                                          mirror_mean=True)
+    ```
+
+4. 配置Ascend环境  
+    以Ascend 910 AI处理器为例，1个8个处理器环境的json配置文件`hccl_config.json`示例如下。单/多处理器环境可以根据以下示例调整`"server_count"`与`device`：
+
+    ```json
+    {
+        "version": "1.0",
+        "server_count": "1",
+        "server_list": [
+            {
+                "server_id": "10.155.111.140",
+                "device": [ba
+                    {"device_id": "0","device_ip": "192.1.27.6","rank_id": "0"},
+                    {"device_id": "1","device_ip": "192.2.27.6","rank_id": "1"},
+                    {"device_id": "2","device_ip": "192.3.27.6","rank_id": "2"},
+                    {"device_id": "3","device_ip": "192.4.27.6","rank_id": "3"},
+                    {"device_id": "4","device_ip": "192.1.27.7","rank_id": "4"},
+                    {"device_id": "5","device_ip": "192.2.27.7","rank_id": "5"},
+                    {"device_id": "6","device_ip": "192.3.27.7","rank_id": "6"},
+                    {"device_id": "7","device_ip": "192.4.27.7","rank_id": "7"}],
+                "host_nic_ip": "reserve"
+            }
+        ],
+        "status": "completed"
+    }
+    ```
+
+    使用Ascend AI处理器时，在代码中，需要在调用Ascend AI处理器开始训练或测试前，按照如下代码设置：
+
+    ```Python
+    elif config.platform == "Ascend":
+        context.set_context(mode=context.GRAPH_MODE, device_target=config.platform, \
+            device_id=config.device_id, save_graphs=False)
+        if config.run_distribute:
+            context.set_auto_parallel_context(device_num=config.rank_size,
+                                              parallel_mode=ParallelMode.DATA_PARALLEL,
+                                              parameter_broadcast=True, mirror_mean=True)
+            auto_parallel_context().set_all_reduce_fusion_split_indices([140])
+            init()
+    ...
+    ```
+
+### 下载代码  
+
+在Gitee中克隆[MindSpore开源项目仓库](https://gitee.com/mindspore/mindspore.git)，进入`./model_zoo/official/cv/mobilenetv2/`。  
+
+```bash
+git clone https://gitee.com/mindspore/mindspore/pulls/5766
+cd ./mindspore/model_zoo/official/cv/mobilenetv2
+```
+
+代码结构如下：
+
+```
+├─MobileNetV2
+    ├─README.md     # descriptions about MobileNetV2
+    ├─scripts
+    │   run_train.sh   # Shell script for train with Ascend or GPU
+    │   run_eval.sh    # Shell script for evaluation with Ascend or GPU
+    ├─src
+    │   config.py      # parameter configuration
+    │   dataset.py     # creating dataset
+    │   launch.py      # start Python script
+    │   lr_generator.py     # learning rate config
+    │   mobilenetV2.py      # MobileNetV2 architecture
+    │   models.py        # net utils to load ckpt_file, define_net...
+    │   utils.py        # net utils to switch precision, set_context and so on
+    ├─train.py      # training script
+    └─eval.py       #  evaluation script
+```
+
+运行增量学习训练与测试时，Windows、Ubuntu与EulersOS上可以使用Python文件`train.py`与`eval.py`，Ubuntu与EulerOS上还可以使用Shell脚本文件`run_train.sh`与`run_eval.sh`。
+
+使用脚本文件`run_train.sh`时，该文件会将运行`launch.py`并且将参数传入`launch.py`，`launch.py`根据分配的CPU、GPU或Ascend AI处理器数量，启动单个/多个进程运行`train.py`，每一个进程分配对应的一个处理器。
+
+### 准备预训练模型  
+
+[下载预训练模型](https://download.mindspore.cn/model_zoo/official/lite/mobilenetv2_openimage_lite/mobilenetV2.ckpt)到以下目录：  
+`./pretrain_checkpoint/[pretrain_checkpoint_file]`  
+
+```Python
+mkdir pretrain_checkpoint
+wget -P ./pretrain_checkpoint https://download.mindspore.cn/model_zoo/official/lite/mobilenetv2_openimage_lite/mobilenetV2.ckpt
+```
+
+### 准备数据
+
+准备ImageFolder格式管理的数据集，运行`run_train.sh`时加入`[dataset_path]`参数，运行`train.py`时加入`--dataset_path [dataset_path]`参数：
+
+数据集结构如下：
+
+```
+└─ImageFolder
+    ├─train  
+    │   class1Folder
+    │   class2Folder
+    │   ......
+    └─eval
+        class1Folder
+        class2Folder
+        ......
+```
+
+## 预训练模型加载代码详解
+
+在增量学习时，需要加载预训练模型。不同数据集和任务中特征提取层（卷积层）分布趋于一致，但是特征向量的组合（全连接层）不相同，分类数量（全连接层output_size)通常也不一致。在增量学习时，只加载与训练特征提取层参数，不加载与训练全连接层参数；在微调与初始训练时，加载与训练特征提取层参数与全连接层参数。
+
+在训练与测试之前，首先按照代码第1行，构建MobileNetV2的backbone网络，head网络，并且构建包含这两个子网络的MobileNetV2网络。代码第4-11行展示了如何在`fine_tune`训练模式下，将预训练模型加载入`net`(MobileNetV2)；在`incremental_learn`训练模式下，将预训练模型分别加载入backbone_net子网络，并且冻结backbone_net中的参数，不参与训练。代码第22-24行展示了如何冻结网络参数。
+
+```Python
+ 1:  backbone_net, head_net, net = define_net(args_opt, config)
+ 2:  ...
+ 3:  def define_net(args, config):
+ 4:      backbone_net = MobileNetV2Backbone(platform=args.platform)
+ 5:      head_net = MobileNetV2Head(input_channel=backbone_net.out_channels, num_classes=config.num_classes)
+ 6:      net = mobilenet_v2(backbone_net, head_net)  
+ 7:      if args.pretrain_ckpt:
+ 8:          if args.train_method == "fine_tune":
+ 9:              load_ckpt(net, args.pretrain_ckpt)
+10:          elif args.train_method == "incremental_learn":
+11:              load_ckpt(backbone_net, args.pretrain_ckpt, trainable=False)
+12:          elif args.train_method == "train":
+13:              pass
+14:          else:
+15:              raise ValueError("must input the usage of pretrain_ckpt when the pretrain_ckpt isn't None")
+16:      return backbone_net, head_net, net
+17:  ...
+18:  def load_ckpt(network, pretrain_ckpt_path, trainable=True):
+19:      """load the pretrain checkpoint and with the param trainable or not"""
+20:      param_dict = load_checkpoint(pretrain_ckpt_path)
+21:      load_param_into_net(network, param_dict)
+22:      if not trainable:
+23:          for param in network.get_parameters():
+24:              param.requires_grad = False
+```
+
+## 参数简介  
+
+### 运行Python文件
+在Windows与Linux系统上训练时，运行`train.py`时需要传入`dataset_path`、`platform`、`train_method`与`pretrain_ckpt`四个参数。验证时，运行`eval.py`并且传入`dataset_path`、`platform`、`pretrain_ckpt`与`head_ckpt`四个参数。
+
+```Shell
+# Windows/Linux train with Python file
+python train.py --dataset_path [dataset_path] --platform [platform] --pretrain_ckpt [pretrain_checkpoint_path] --train_method[("train", "fine_tune", "incremental_learn")]
+
+# Windows/Linux eval with Python file
+python eval.py --dataset_path [dataset_path] --platform [platform] --pretrain_ckpt [pretrain_checkpoint_path] --head_ckpt [head_ckpt_path]
+```
+
+- `--dataset_path`：训练与验证数据集地址，无默认值，用户训练/验证时必须输入。
+- `--platform`：处理器类型，默认为“Ascend”，可以设置为“CPU”或"GPU"。
+- `--train_method`：训练方法，必须输入“train"、"fine_tune"和incremental_learn"其中一个。
+- `--pretrain_ckpt`：增量训练或调优时，需要传入pretrain_checkpoint文件路径以加载预训练好的模型参数权重。
+- `--head_ckpt`：增量训练模型验证时，需要传入head_net预训练模型路径以加载预训练好的模型参数权重。
+
+
+### 运行Shell脚本
+在Linux系统上时，可以选择运行Shell脚本文件`./scripts/run_train.sh`与`./scripts/run_eval.sh`。运行时需要在交互界面中同时传入参数。  
+
+```Shell
+# Windows doesn't support Shell
+# Linux train with Shell script 
+sh run_train.sh [PLATFORM] [DEVICE_NUM] [VISIABLE_DEVICES(0,1,2,3,4,5,6,7)] [RANK_TABLE_FILE] [DATASET_PATH] [TRAIN_METHOD] [CKPT_PATH]
+
+# Linux eval with Shell script for incremental learn
+sh run_eval.sh [PLATFORM] [DATASET_PATH] [PRETRAIN_CKPT_PATH] [HEAD_CKPT_PATH]
+```
+
+- `[PLATFORM]`：处理器类型，默认为“Ascend”，可以设置为“GPU”。
+- `[DEVICE_NUM]`：每个节点（一台服务器/PC相当于一个节点）进程数量，建议设置为机器上Ascend AI处理器数量或GPU数量。
+- `[VISIABLE_DEVICES(0,1,2,3,4,5,6,7)]`：字符串格式的的设备ID，训练将会根据`[VISIABLE_DEVICES]`将进程绑定到对应ID的设备上，多个设备ID之间使用','分隔，建议ID数量与进程数量相同。
+- `[RANK_TABLE_FILE]`：platform选择Ascend时，需要配置Ascend的配置Json文件,。
+- `[DATASET_PATH]`：训练与验证数据集地址，无默认值，用户训练/验证时必须输入。
+- `[CKPT_PATH]`：增量训练或调优时，需要传入checkpoint文件路径以加载预训练好的模型参数权重。
+- `[TRAIN_METHOD]`：训练方法，必须输入`train`、`fine_tune`和`incremental_learn`其中一个。
+- `[PRETRAIN_CKPT_PATH]`：针对增量学习的模型做验证时，需要输入主干网络层保存模型路径。
+- `[HEAD_CKPT_PATH]`：针对增量学习的模型做验证时，需要输入全连接层保存模型路径。
+
+## 加载增量学习训练  
+
+Windows系统上，MobileNetV2做增量学习训练时，只能运行`train.py`。Linux系统上，使用MobileNetV2做增量学习训练时，可以选择运行`run_train.sh`， 并在运行Shell脚本文件时传入[参数](#参数简介)。
+
+Windows系统输出信息到交互式命令行，Linux系统环境下运行`run_train.sh`时，命令行结尾使用`&> [log_file_path]`将标准输出与错误输出写入log文件。 增量学习成功开始训练，`./train/device*/log*.log`中会持续写入每一个epoch的训练时间与Loss等信息。若未成功，上述log文件会写入失败报错信息。
+
+### CPU加载训练  
+
+- 设置节点数量
+
+  目前运行`train.py`时仅支持单处理器，不需要调整处理器数量。运行`run_train.sh`文件时，`CPU`设备默认为单处理器，目前暂不支持修改CPU数量。
+
+- 开始增量训练
+
+  使用样例1：通过Python文件调用1个CPU处理器。
+
+    ```Shell
+    # Windows or Linux with Python
+    python train.py --platform CPU --dataset_path /store/dataset/OpenImage/train/ -- train_method incremental_learn --pretrain_ckpt ./pretrain_checkpoint/mobilenetV2.ckpt
+    ```
+
+  使用样例2：通过Shell文件调用1个CPU处理器。
+
+    ```Shell
+    # Linux with Shell
+    sh run_train.sh CPU /store/dataset/OpenImage/train/ incremental_learn ../pretrain_checkpoint/mobilenetV2.ckpt
+    ```
+
+### GPU加载训练  
+
+- 设置节点数量
+
+  目前运行`train.py`时仅支持单处理器，不需要调整节点数量。运行`run_train.sh`文件时，设置`[nproc_per_node]`为GPU数量， `[visible_devices]`为可使用的处理器编号，即GPU的ID，可以选择一个或多个设备ID，使用`,`隔开。
+
+- 开始增量训练
+
+  - 使用样例1：通过Python文件调用1个GPU处理器。
+
+    ```Shell
+    # Windows or Linux with Python
+    python train.py --platform GPU --dataset_path /store/dataset/OpenImage/train/ --pretrain_ckpt ./pretrain_checkpoint/mobilenetV2.ckpt --train_method incremental_learn
+    ```
+
+  - 使用样例2：通过Shell脚本调用1个GPU处理器，设备ID为`“0”`。
+
+    ```Shell
+    # Linux with Shell
+    sh run_train.sh GPU 1 0 /store/dataset/OpenImage/train/ incremental_learn ../pretrain_checkpoint/mobilenetV2.ckpt
+    ```
+
+  - 使用样例3：通过Shell脚本调用8个GPU处理器，设备ID为`“0,1,2,3,4,5,6,7”`。
+
+    ```Shell
+    # Linux with Shell
+    sh run_train.sh GPU 8 0,1,2,3,4,5,6,7 /store/dataset/OpenImage/train/ incremental_learn ../pretrain_checkpoint/mobilenetV2.ckpt
+    ```
+
+### Ascend加载训练  
+
+- 设置节点数量
+
+  目前运行`train.py`时仅支持单处理器，不需要调整节点数量。运行`run_train.sh`文件时，设置`[nproc_per_node]`为Ascend AI处理器数量， `[visible_devices]`为可使用的处理器编号，即Ascend AI处理器的ID，8卡服务器可以选择0-7中一个或多个设备ID，使用`,`隔开。Ascend节点处理器数量目前只能设置为1或者8。
+
+- 开始增量训练
+
+  - 使用样例1：通过Python文件调用1个Ascend处理器。
+
+    ```Shell
+    # Windows or Linux with Python
+    python train.py --platform Ascend --dataset_path /store/dataset/OpenImage/train/ --train_method incremental_learn --pretrain_ckpt  ./pretrain_checkpoint/mobilenetV2.ckpt
+    ```
+
+  - 使用样例2：通过Shell脚本调用1个Ascend AI处理器，设备ID为“0”。
+
+    ```Shell
+    # Linux with Shell
+    sh run_train.sh Ascend 1 0 ~/rank_table.json /store/dataset/OpenImage/train/ incremental_learn ../pretrain_checkpoint/mobilenetV2.ckpt
+    ```
+
+  - 使用样例3：通过Shell脚本调用8个Ascend AI处理器，设备ID为”0,1,2,3,4,5,6,7“。
+
+    ```Shell
+    # Linux with Shell
+    sh run_train.sh Ascend 8 0,1,2,3,4,5,6,7 ~/rank_table.json /store/dataset/OpenImage/train/ incremental_learn ../pretrain_checkpoint/mobilenetV2.ckpt
+    ```
+
+### 增量学习训练结果  
+
+- 查看运行结果。
+
+  - 运行Python文件时在交互式命令行中查看打印信息，`Linux`上运行Shell脚本运行后使用`cat ./train/device0/log0.log`中查看打印信息，输出结果如下：
+
+    ```Shell
+    train args: Namespace(dataset_path='.\\dataset\\train', platform='CPU', \
+    pretrain_ckpt='.\\pretrain_checkpoint\\mobilenetV2.ckpt', train_method='incremental_learn')
+    cfg: {'num_classes': 26, 'image_height': 224, 'image_width': 224, 'batch_size': 150, \
+    'epoch_size': 15, 'warmup_epochs': 0, 'lr_max': 0.03, 'lr_end': 0.03, 'momentum': 0.9, \
+    'weight_decay': 4e-05, 'label_smooth': 0.1, 'loss_scale': 1024, 'save_checkpoint': True, \
+    'save_checkpoint_epochs': 1, 'keep_checkpoint_max': 20, 'save_checkpoint_path': './checkpoint', \
+    'platform': 'CPU'}
+    Processing batch: 16: 100%|███████████████████████████████████████████ █████████████████████| 16/16 [00:00<?, ?it/s]
+    epoch[15], iter[16] cost: 256.030, per step time: 256.030, avg loss: 1.775total cos 7.2574 s
+    ```
+
+- 查看保存的checkpoint文件。
+
+  - Windows上使用`dir checkpoint`查看保存的模型文件：
+
+    ```Shell
+    dir checkpoint
+    2020//0814 11:20        267,727 mobilenetv2_head_1.ckpt
+    2020//0814 11:21        267,727 mobilenetv2_head_10.ckpt
+    2020//0814 11:21        267,727 mobilenetv2_head_11.ckpt
+    ...
+    2020//0814 11:21        267,727 mobilenetv2_head_7.ckpt
+    2020//0814 11:21        267,727 mobilenetv2_head_8.ckpt
+    2020//0814 11:21        267,727 mobilenetv2_head_9.ckpt
+    ```
+
+  - Linux上使用`ls ./checkpoint`查看保存的模型文件：
+
+    ```Shell
+    ls ./checkpoint/
+    mobilenetv2_head_1.ckpt  mobilenetv2_head_2.ckpt
+    mobilenetv2_head_3.ckpt  mobilenetv2_head_4.ckpt
+    ...
+    ```
+## 验证增量学习训练模型
+
+### 验证模型
+
+使用验证集测试模型性能，需要输入必要[参数](#参数简介)，`--platform`默认为“Ascend”，可自行设置为"CPU"或"GPU"。最终在交互式命令行中展示标准输出与错误输出，或者将其写入`infer.log`文件。
+
+```Shell
+# Windows/Linux with Python
+python eval.py --dataset_path \store\dataset\openimage\val\ --platform CPU pretrain_ckpt .\pretrain_checkpoint\mobilenetV2.ckpt --head_ckpt .\checkpoint\mobilenetv2_head_15,ckpt
+
+# Linux with Shell
+sh run_infer.sh CPU /store/dataset/openimage/val/ ../pretrain_checkpoint/mobilenetV2.ckpt ../checkpoint/mobilenetv2_head_15.ckpt
+```
+
+### 验证结果
+
+- 运行Python文件时在交互式命令行中输出验证结果，Shell脚本将把这些信息写入`./infer.log`中，需要使用`cat ./infer.log`查看，以Window运行结果为例，结果如下：
+
+  ```Shell
+  result:{'acc': 0.9466666666666666666667}
+  pretrain_ckpt = .\pretrain_checkpoint\mobilenetV2.ckpt
+  head_ckpt = .\checkpoint\mobilenetv2_head_15.ckpt
+  ```
diff --git a/tutorials/source_zh_cn/advanced_use/model_security.md b/tutorials/source_zh_cn/advanced_use/model_security.md
index 13850029cdc90c80586c0e6cd8c58438068c55a2..1d445b489b6f98f7dc6c2440b768c982f68084a5 100644
--- a/tutorials/source_zh_cn/advanced_use/model_security.md
+++ b/tutorials/source_zh_cn/advanced_use/model_security.md
@@ -185,7 +185,7 @@ def generate_mnist_dataset(data_path, batch_size=32, repeat_size=1,
                                       batch_size=batch_size, repeat_size=1,
                                       sparse=False)
     net = LeNet5()
-    loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=False)
+    loss = SoftmaxCrossEntropyWithLogits(sparse=False)
     opt = nn.Momentum(net.trainable_params(), 0.01, 0.09)
     model = Model(net, loss, opt, metrics=None)
     model.train(10, ds_train, callbacks=[LossMonitor()],
diff --git a/tutorials/source_zh_cn/advanced_use/nlp_application.md b/tutorials/source_zh_cn/advanced_use/nlp_application.md
index 3b8d9e3c48329f9eaa6832ad6fd0aee2c54400f3..dd6df6a34bf637c5a757dd9de7b75a09e5bc1f86 100644
--- a/tutorials/source_zh_cn/advanced_use/nlp_application.md
+++ b/tutorials/source_zh_cn/advanced_use/nlp_application.md
@@ -193,7 +193,7 @@ if args.pre_trained:
 定义优化器及损失函数的示例代码如下：
 
 ```python
-loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True)
+loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
 opt = nn.Momentum(network.trainable_params(), cfg.learning_rate, cfg.momentum)
 loss_cb = LossMonitor()
 ```
diff --git a/tutorials/source_zh_cn/advanced_use/optimize_the_performance_of_data_preparation.md b/tutorials/source_zh_cn/advanced_use/optimize_the_performance_of_data_preparation.md
index e5fce293fc4b9a2fc7ec48a72f591a8ee7c924b9..05ea6013c205d31cfa5f5dac10893569a9a2a91a 100644
--- a/tutorials/source_zh_cn/advanced_use/optimize_the_performance_of_data_preparation.md
+++ b/tutorials/source_zh_cn/advanced_use/optimize_the_performance_of_data_preparation.md
@@ -251,9 +251,9 @@ shuffle性能优化建议如下：
     for data in ds2.create_dict_iterator():
         print(data["data"])
     ```
-    ```
-    输出：
 
+    输出：
+    ```
     before shuffle:
     [0 1 2 3 4]
     [1 2 3 4 5]
diff --git a/tutorials/source_zh_cn/advanced_use/second_order_optimizer_for_resnet50_application.md b/tutorials/source_zh_cn/advanced_use/second_order_optimizer_for_resnet50_application.md
index 55371f8a0c3c4901ce44be4f1e8ccba74a35af1a..440e668f078e246efc79b54732801731cb633ffe 100644
--- a/tutorials/source_zh_cn/advanced_use/second_order_optimizer_for_resnet50_application.md
+++ b/tutorials/source_zh_cn/advanced_use/second_order_optimizer_for_resnet50_application.md
@@ -351,7 +351,7 @@ epoch: 42 step: 5004, loss is 1.6453942
 其中，
 `*.ckpt`：指保存的模型参数文件。checkpoint文件名称具体含义：*网络名称*-*epoch数*_*step数*.ckpt。
 
-##### GPU
+#### GPU
 在GPU硬件平台上，MindSpore采用OpenMPI的`mpirun`进行分布式训练，进程创建1个目录，目录名称为`train_parallel`，用来保存日志信息和训练的checkpoint文件。下面以使用8张卡的分布式训练脚本为例，演示如何运行脚本：
 ```
 sh run_distribute_train_gpu.sh [DATASET_PATH] [DEVICE_NUM]
diff --git a/tutorials/source_zh_cn/advanced_use/summary_record.md b/tutorials/source_zh_cn/advanced_use/summary_record.md
index 16c459c1800d0b9126fe7941dab15e7823bdd83f..8854964cdb985b00cb8dc104b3b37171ae3ac636 100644
--- a/tutorials/source_zh_cn/advanced_use/summary_record.md
+++ b/tutorials/source_zh_cn/advanced_use/summary_record.md
@@ -108,7 +108,7 @@ class AlexNet(nn.Cell):
 context.set_context(mode=context.GRAPH_MODE)
 
 network = AlexNet(num_classes=10)
-loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
 lr = Tensor(0.1)
 opt = nn.Momentum(network.trainable_params(), lr, momentum=0.9)
 model = Model(network, loss, opt)
diff --git a/tutorials/source_zh_cn/advanced_use/use_on_the_cloud.md b/tutorials/source_zh_cn/advanced_use/use_on_the_cloud.md
index 6fbc1722b67c71ce7dc3d81047c8d3002b4d7bfb..4f88abb2f408816c93c4d184a923008f875c337e 100644
--- a/tutorials/source_zh_cn/advanced_use/use_on_the_cloud.md
+++ b/tutorials/source_zh_cn/advanced_use/use_on_the_cloud.md
@@ -164,13 +164,13 @@ MindSpore暂时没有提供直接访问OBS数据的接口，需要通过MoXing
     ```python
     import os
     from mindspore import context
-    from mindspore.train.model import ParallelMode
+    from mindspore.context import ParallelMode
 
     device_num = int(os.getenv('RANK_SIZE'))
     if device_num > 1:
         context.set_auto_parallel_context(device_num=device_num,
                                           parallel_mode=ParallelMode.DATA_PARALLEL,
-                                          mirror_mean=True)
+                                          gradients_mean=True)
     ```
 
 ### 示例代码
@@ -183,7 +183,7 @@ MindSpore暂时没有提供直接访问OBS数据的接口，需要通过MoXing
 import os
 import argparse
 from mindspore import context
-from mindspore.train.model import ParallelMode
+from mindspore.context import ParallelMode
 import mindspore.dataset.engine as de
 
 device_id = int(os.getenv('DEVICE_ID'))
@@ -201,7 +201,7 @@ def resnet50_train(args_opt):
     if device_num > 1:
         context.set_auto_parallel_context(device_num=device_num,
                                           parallel_mode=ParallelMode.DATA_PARALLEL,
-                                          mirror_mean=True)
+                                          gradients_mean=True)
     train_dataset = create_dataset(local_data_path)
 
 if __name__ == '__main__':
@@ -220,7 +220,7 @@ if __name__ == '__main__':
 import os
 import argparse
 from mindspore import context
-from mindspore.train.model import ParallelMode
+from mindspore.context import ParallelMode
 import mindspore.dataset.engine as de
 
 # adapt to cloud: used for downloading data
@@ -244,7 +244,7 @@ def resnet50_train(args_opt):
     if device_num > 1:
         context.set_auto_parallel_context(device_num=device_num,
                                           parallel_mode=ParallelMode.DATA_PARALLEL,
-                                          mirror_mean=True)
+                                          gradients_mean=True)
         # adapt to cloud: define distributed local data path
         local_data_path = os.path.join(local_data_path, str(device_id))
 
diff --git a/tutorials/source_zh_cn/index.rst b/tutorials/source_zh_cn/index.rst
index aed7fc45d443603f2521568f671184c2e5259b1c..38bee6d4f1184cb08f4a26cd022cf73812aba611 100644
--- a/tutorials/source_zh_cn/index.rst
+++ b/tutorials/source_zh_cn/index.rst
@@ -36,6 +36,7 @@ MindSpore教程
    advanced_use/synchronization_training_and_evaluation
    advanced_use/bert_poetry
    advanced_use/optimize_the_performance_of_data_preparation
+   advanced_use/mobilenetv2_incremental_learn
 
 .. toctree::
    :glob:
diff --git a/tutorials/source_zh_cn/quick_start/quick_start.md b/tutorials/source_zh_cn/quick_start/quick_start.md
index cfaa8a05397c1589967608d094d1e006b6f295d7..ac26e962ae76186e58546fd6ea9feb4d20b40778 100644
--- a/tutorials/source_zh_cn/quick_start/quick_start.md
+++ b/tutorials/source_zh_cn/quick_start/quick_start.md
@@ -204,20 +204,20 @@ MindSpore支持`TruncatedNormal`、`Normal`、`Uniform`等多种参数初始化
 
 ```python
 import mindspore.nn as nn
+from mindspore.common.initializer import Normal
 
 class LeNet5(nn.Cell):
     """
     Lenet network structure
     """
     #define the operator required
-    def __init__(self, num_class=10, channel=1):
+    def __init__(self, num_class=10, num_channel=1):
         super(LeNet5, self).__init__()
-        self.num_class = num_class
-        self.conv1 = nn.Conv2d(channel, 6, 5, pad_mode='valid')
+        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
         self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
-        self.fc1 = nn.Dense(16 * 5 * 5, 120)
-        self.fc2 = nn.Dense(120, 84)
-        self.fc3 = nn.Dense(84, self.num_class)
+        self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
+        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
+        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
         self.relu = nn.ReLU()
         self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
         self.flatten = nn.Flatten()
@@ -258,7 +258,7 @@ from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
 if __name__ == "__main__":
     ...
     #define the loss function
-    net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')
+    net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
     ...
 ```
 
@@ -347,18 +347,20 @@ python lenet.py --device_target=CPU
 训练过程中loss打印示例如下：
 
 ```bash
+epoch: 1 step: 1, loss is 2.3025916
+epoch: 1 step: 2, loss is 2.302577
+epoch: 1 step: 3, loss is 2.3023994
+epoch: 1 step: 4, loss is 2.303059
+epoch: 1 step: 5, loss is 2.3025753
+epoch: 1 step: 6, loss is 2.3027692
+epoch: 1 step: 7, loss is 2.3026521
+epoch: 1 step: 8, loss is 2.3014607
 ...
-epoch: 1 step: 262, loss is 1.9212162
-epoch: 1 step: 263, loss is 1.8498616
-epoch: 1 step: 264, loss is 1.7990671
-epoch: 1 step: 265, loss is 1.9492403
-epoch: 1 step: 266, loss is 2.0305142
-epoch: 1 step: 267, loss is 2.0657792
-epoch: 1 step: 268, loss is 1.9582214
-epoch: 1 step: 269, loss is 0.9459006
-epoch: 1 step: 270, loss is 0.8167224
-epoch: 1 step: 271, loss is 0.7432692
-...
+epoch: 1 step: 1871, loss is 0.048939988
+epoch: 1 step: 1872, loss is 0.028885357
+epoch: 1 step: 1873, loss is 0.09475248
+epoch: 1 step: 1874, loss is 0.046067055
+epoch: 1 step: 1875, loss is 0.12366105
 ```
 
 训练完后，即保存的模型文件，示例如下:
@@ -417,7 +419,7 @@ python lenet.py --device_target=CPU
 ```
 ...
 ============== Starting Testing ==============
-============== Accuracy:{'Accuracy': 0.9742588141025641} ==============
+============== Accuracy:{'Accuracy': 0.9663477564102564} ==============
 ```
 
-可以在打印信息中看出模型精度数据，示例中精度数据达到97.4%，模型质量良好。
+可以在打印信息中看出模型精度数据，示例中精度数据达到96.6%，模型质量良好。随着网络迭代次数`epoch_size`增加，模型精度会进一步提高。
diff --git a/tutorials/source_zh_cn/quick_start/quick_video.md b/tutorials/source_zh_cn/quick_start/quick_video.md
index 8c80d69900ac81b649b73b561bb415255fccfb3d..115ef7d67eb12823b13bf53497ec534d318aeefd 100644
--- a/tutorials/source_zh_cn/quick_start/quick_video.md
+++ b/tutorials/source_zh_cn/quick_start/quick_video.md
@@ -257,6 +257,30 @@
                     </svg>
                </a>
           </div>
+          <div
+               class="video-item-wraper" style="width: 33.3%;display: flex;justify-content: center;align-items: center;padding: 10px;box-sizing: border-box;">
+               <a href="https://www.mindspore.cn/tutorial/zh-CN/master/quick_start/quick_video/mindInsight_lineage_and_scalars_comparision.html" target="_blank"
+                    style="position: relative;">
+                    <img src="https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/teaching_video/cover/%E6%89%8B%E6%8A%8A%E6%89%8B%E7%B3%BB%E5%88%97/MindInsight%20%E5%AF%B9%E6%AF%94%E7%9C%8B%E6%9D%BF%E6%B1%87%E6%80%BB%E9%A1%B5.png"
+                         style="max-width: 100%;width: 400px;">
+                    <svg style="position: absolute;left: 50%;top: 50%;width: 30px;height: 30px;transform: translate(-50%, -50%);"
+                         data-v-1534670d="" id="图层_1" data-name="图层 1" xmlns="http://www.w3.org/2000/svg"
+                         viewBox="0 0 30 30" class="icon-position">
+                         <title data-v-1534670d="">play</title>
+                         <g data-v-1534670d="" style="opacity: 0.3;">
+                              <path data-v-1534670d="" d="M301.21,376.21a15,15,0,1,1-15,15A15,15,0,0,1,301.21,376.21Z"
+                                   transform="translate(-286.21 -376.21)"
+                                   style="fill: rgb(255, 255, 255); fill-rule: evenodd;"></path>
+                         </g>
+                         <path data-v-1534670d=""
+                              d="M301.21,377.21a14,14,0,1,1-14,14,14,14,0,0,1,14-14m0-1a15,15,0,1,0,15,15,15,15,0,0,0-15-15Z"
+                              transform="translate(-286.21 -376.21)" style="fill: rgb(255, 255, 255);"></path>
+                         <path data-v-1534670d=""
+                              d="M308.15,392.32l-9.39,5.28c-.72.41-1.31.06-1.31-.76v-10.5c0-.83.58-1.17,1.31-.76l9.39,5.28C308.87,391.25,308.87,391.91,308.15,392.32Z"
+                              transform="translate(-286.21 -376.21)" style="fill: rgb(255, 255, 255);"></path>
+                    </svg>
+               </a>
+          </div>
      </div>
 
 </body>
diff --git a/tutorials/source_zh_cn/quick_start/quick_video/mindInsight_lineage_and_scalars_comparision.md b/tutorials/source_zh_cn/quick_start/quick_video/mindInsight_lineage_and_scalars_comparision.md
new file mode 100644
index 0000000000000000000000000000000000000000..b04ec401cc5adc3df4d077672e82ef1aec82c210
--- /dev/null
+++ b/tutorials/source_zh_cn/quick_start/quick_video/mindInsight_lineage_and_scalars_comparision.md
@@ -0,0 +1,11 @@
+# MindInsight溯源与对比看板
+
+[comment]: <> (本文档中包含手把手系列视频，码云Gitee不支持展示，请于官方网站对应教程中查看)
+
+<video id="video7" autoplay controls width="1200px" height="600px" poster="https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/teaching_video/cover/%E6%89%8B%E6%8A%8A%E6%89%8B%E7%B3%BB%E5%88%97/MindInsight%20%E5%AF%B9%E6%AF%94%E7%9C%8B%E6%9D%BF%E8%AF%A6%E6%83%85%E9%A1%B5.png">
+<source id="mp47" src="https://mindspore-website.obs.cn-north-4.myhuaweicloud.com:443/teaching_video/video/%E6%BA%AF%E6%BA%90%E4%B8%8E%E5%AF%B9%E6%AF%94%E7%9C%8B%E6%9D%BF.mp4" type="video/mp4">
+</video>
+
+**立即安装**：<https://www.mindspore.cn/install>
+
+**查看更多内容**：<https://www.mindspore.cn/tutorial/zh-CN/master/advanced_use/lineage_and_scalars_comparision.html>
\ No newline at end of file
diff --git a/tutorials/source_zh_cn/use/multi_platform_inference.md b/tutorials/source_zh_cn/use/multi_platform_inference.md
index 77698182e542f89bc8270c7b3d5ba298c31453a1..83b588e41ac2d16d8816fbe1294079b5451d903f 100644
--- a/tutorials/source_zh_cn/use/multi_platform_inference.md
+++ b/tutorials/source_zh_cn/use/multi_platform_inference.md
@@ -62,7 +62,7 @@ CPU | ONNX格式 | 支持ONNX推理的runtime/SDK，如TensorRT。
    首先构建模型，然后使用`mindspore.train.serialization`模块的`load_checkpoint`和`load_param_into_net`从本地加载模型与参数，传入验证数据集后即可进行模型推理，验证数据集的处理方式与训练数据集相同。
     ```python
     network = LeNet5(cfg.num_classes)
-    net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
     net_opt = nn.Momentum(network.trainable_params(), cfg.lr, cfg.momentum)
     model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
 
@@ -84,7 +84,7 @@ CPU | ONNX格式 | 支持ONNX推理的runtime/SDK，如TensorRT。
    首先构建模型，然后使用`hub.load_weights`从云端加载模型参数，传入验证数据集后即可进行推理，验证数据集的处理方式与训练数据集相同。
     ```python
     network = LeNet5(cfg.num_classes)
-    net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
     net_opt = nn.Momentum(network.trainable_params(), cfg.lr, cfg.momentum)
     model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
 
diff --git a/tutorials/tutorial_code/distributed_training/resnet50_distributed_training.py b/tutorials/tutorial_code/distributed_training/resnet50_distributed_training.py
index a8a42109f9d23e740323b5ad7cf9c59027145b54..4a3e56e56695cd55fe364cd62562bae6b9fb11a7 100644
--- a/tutorials/tutorial_code/distributed_training/resnet50_distributed_training.py
+++ b/tutorials/tutorial_code/distributed_training/resnet50_distributed_training.py
@@ -28,7 +28,8 @@ from mindspore.communication.management import init, get_rank, get_group_size
 from mindspore import Tensor
 from mindspore.ops import operations as P
 from mindspore.nn.optim.momentum import Momentum
-from mindspore.train.model import Model, ParallelMode
+from mindspore.train.model import Model
+from mindspore.context import ParallelMode
 from mindspore import context
 from mindspore.train.callback import LossMonitor
 from resnet import resnet50
@@ -117,7 +118,7 @@ class SoftmaxCrossEntropyExpand(nn.Cell):
 
 
 def test_train_cifar(epoch_size=10):
-    context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL, mirror_mean=True)
+    context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL, gradients_mean=True)
     loss_cb = LossMonitor()
     data_path = os.getenv('DATA_PATH')
     dataset = create_dataset(data_path)
diff --git a/tutorials/tutorial_code/gradient_accumulation/train.py b/tutorials/tutorial_code/gradient_accumulation/train.py
index e9ff0f6c1f280a0338bb97937a1aa60e9ea126e5..c52fd0d63fbb62bde920a77413e9c73198a8464e 100644
--- a/tutorials/tutorial_code/gradient_accumulation/train.py
+++ b/tutorials/tutorial_code/gradient_accumulation/train.py
@@ -139,7 +139,7 @@ if __name__ == "__main__":
     ds_train = create_dataset(os.path.join(args.data_path, "train"), 32)
 
     network = LeNet5(10)
-    net_loss = nn.SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction="mean")
+    net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
     net_opt = nn.Momentum(network.trainable_params(), 0.01, 0.9)
     model = GradientAccumulation(network, net_loss, net_opt)
 
diff --git a/tutorials/tutorial_code/lenet.py b/tutorials/tutorial_code/lenet.py
index 13f987066a9a768870a11609a2e02717e5393422..0d3848b69bf9b5a7b89d958f6990bea0e24f85a0 100644
--- a/tutorials/tutorial_code/lenet.py
+++ b/tutorials/tutorial_code/lenet.py
@@ -23,6 +23,7 @@ import argparse
 import mindspore.dataset as ds
 import mindspore.nn as nn
 from mindspore import context
+from mindspore.common.initializer import Normal
 from mindspore.train.serialization import load_checkpoint, load_param_into_net
 from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
 from mindspore.train import Model
@@ -120,14 +121,13 @@ def create_dataset(data_path, batch_size=32, repeat_size=1,
 class LeNet5(nn.Cell):
     """Lenet network structure."""
     # define the operator required
-    def __init__(self, num_class=10, channel=1):
+    def __init__(self, num_class=10, num_channel=1):
         super(LeNet5, self).__init__()
-        self.num_class = num_class
-        self.conv1 = nn.Conv2d(channel, 6, 5, pad_mode='valid')
+        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
         self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
-        self.fc1 = nn.Dense(16 * 5 * 5, 120)
-        self.fc2 = nn.Dense(120, 84)
-        self.fc3 = nn.Dense(84, self.num_class)
+        self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
+        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
+        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
         self.relu = nn.ReLU()
         self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
         self.flatten = nn.Flatten()
@@ -179,7 +179,7 @@ if __name__ == "__main__":
     epoch_size = 1
     mnist_path = "./MNIST_Data"
     # define the loss function
-    net_loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=True, reduction='mean')
+    net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
     repeat_size = 1
     # create the network
     network = LeNet5()
diff --git a/tutorials/tutorial_code/model_safety/mnist_defense_nad.py b/tutorials/tutorial_code/model_safety/mnist_defense_nad.py
index a76c2a6016a34d6cdde18b897295021aef384935..d587f960acefeaf494c48964fe344d39b209fa15 100644
--- a/tutorials/tutorial_code/model_safety/mnist_defense_nad.py
+++ b/tutorials/tutorial_code/model_safety/mnist_defense_nad.py
@@ -57,7 +57,7 @@ def test_nad_method():
     load_dict = load_checkpoint(ckpt_name)
     load_param_into_net(net, load_dict)
 
-    loss = SoftmaxCrossEntropyWithLogits(is_grad=False, sparse=False)
+    loss = SoftmaxCrossEntropyWithLogits(sparse=False)
     opt = nn.Momentum(net.trainable_params(), 0.01, 0.09)
 
     nad = NaturalAdversarialDefense(net, loss_fn=loss, optimizer=opt,
diff --git a/tutorials/tutorial_code/resnet/cifar_resnet50.py b/tutorials/tutorial_code/resnet/cifar_resnet50.py
index 94cca8b461eb6d9336c4fdabb70bf19fdd8fbc9d..06cec7a822cb96cb20a31d2d94fbd54096f62eae 100644
--- a/tutorials/tutorial_code/resnet/cifar_resnet50.py
+++ b/tutorials/tutorial_code/resnet/cifar_resnet50.py
@@ -29,7 +29,8 @@ from mindspore.communication.management import init
 from mindspore import Tensor
 from mindspore.ops import operations as P
 from mindspore.nn.optim.momentum import Momentum
-from mindspore.train.model import Model, ParallelMode
+from mindspore.train.model import Model
+from mindspore.context import ParallelMode
 from mindspore import context
 from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor
 from mindspore.train.serialization import load_checkpoint, load_param_into_net
@@ -111,7 +112,7 @@ if __name__ == '__main__':
 
     epoch_size = args_opt.epoch_size
     net = resnet50(args_opt.batch_size, args_opt.num_classes)
-    ls = SoftmaxCrossEntropyWithLogits(sparse=True, is_grad=False, reduction="mean")
+    ls = SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
     opt = Momentum(filter(lambda x: x.requires_grad, net.get_parameters()), 0.01, 0.9)
 
     model = Model(net, loss_fn=ls, optimizer=opt, metrics={'acc'})
diff --git a/tutorials/tutorial_code/sample_for_cloud/resnet50_train.py b/tutorials/tutorial_code/sample_for_cloud/resnet50_train.py
index 0fbd10391430c4d05db2a75efe74826af67c5690..183f3ba73972c3f2aba21edcab6a0771321d169e 100644
--- a/tutorials/tutorial_code/sample_for_cloud/resnet50_train.py
+++ b/tutorials/tutorial_code/sample_for_cloud/resnet50_train.py
@@ -24,7 +24,8 @@ from mindspore import context
 from mindspore import Tensor
 from mindspore.nn.optim.momentum import Momentum
 from mindspore.nn.loss import SoftmaxCrossEntropyWithLogits
-from mindspore.train.model import Model, ParallelMode
+from mindspore.train.model import Model
+from mindspore.context import ParallelMode
 from mindspore.train.callback import Callback, LossMonitor
 from mindspore.train.loss_scale_manager import FixedLossScaleManager
 from mindspore.communication.management import init
@@ -121,7 +122,7 @@ def resnet50_train(args_opt):
     if device_num > 1:
         context.set_auto_parallel_context(device_num=device_num,
                                           parallel_mode=ParallelMode.DATA_PARALLEL,
-                                          mirror_mean=True)
+                                          gradients_mean=True)
         init()
         local_data_path = os.path.join(local_data_path, str(device_id))