diff --git a/tutorials/source_zh_cn/beginner/accelerate_with_static_graph.ipynb b/tutorials/source_zh_cn/beginner/accelerate_with_static_graph.ipynb
index 859df930b106635bfa21ecd726d8669607ae00be..0fd1f96ef37ba4182cfb99023aed73f0a6fb2d21 100644
--- a/tutorials/source_zh_cn/beginner/accelerate_with_static_graph.ipynb
+++ b/tutorials/source_zh_cn/beginner/accelerate_with_static_graph.ipynb
@@ -13,13 +13,13 @@
     "\n",
     "## 背景介绍\n",
     "\n",
-    "AI编译框架分为两种运行模式：动态图模式和静态图模式。MindSpore默认情况下是以动态图模式运行，但也支持手工切换为静态图模式。两种运行模式的详细介绍如下：\n",
+    "AI编译框架有两种运行模式：动态图模式和静态图模式。MindSpore默认情况下是以动态图模式运行，但也支持手动切换为静态图模式。两种运行模式的详细介绍如下：\n",
     "\n",
     "### 动态图模式\n",
     "\n",
-    "动态图的特点是计算图的构建和计算同时发生（Define by run），其符合Python的解释执行方式，在计算图中定义一个Tensor时，其值就已经被计算且确定，因此在调试模型时较为方便，能够实时得到中间结果的值，但由于所有节点都需要被保存，导致难以对整个计算图进行优化。\n",
+    "动态图的特点是计算图的构建和计算同时发生（Define by run），符合Python的解释执行方式。在计算图中定义一个Tensor时，其值就已经被计算且确定，因此在调试模型时较为方便，能够实时得到中间结果的值。但由于所有节点都需要被保存，导致难以对整个计算图进行优化。\n",
     "\n",
-    "在MindSpore中，动态图模式又被称为PyNative模式。由于动态图的解释执行特性，在脚本开发和网络流程调试过程中，推荐使用动态图模式进行调试。\n",
+    "在MindSpore中，动态图模式又被称为PyNative模式。由于动态图的解释执行特性，在脚本开发和网络流程调试过程中，推荐使用动态图模式。\n",
     "\n",
     "如需要手动控制框架采用PyNative模式，可以通过以下代码进行网络构建："
    ]
@@ -165,17 +165,17 @@
    "source": [
     "## 静态图模式的使用场景\n",
     "\n",
-    "MindSpore编译器重点面向Tensor数据的计算以及其微分处理。因此使用MindSpore API以及基于Tensor对象的操作更适合使用静态图编译优化。其他操作虽然可以部分入图编译，但实际优化作用有限。另外，静态图模式先编译后执行的模式导致其存在编译耗时。因此，如果函数无需反复执行，那么Graph Mode加速也可能没有价值。\n",
+    "MindSpore编译器重点面向Tensor数据的计算以及其微分处理。因此，使用MindSpore API以及基于Tensor对象的操作，更适合使用静态图编译优化。其他操作虽然可以部分入图编译，但实际优化作用有限。另外，静态图模式采用先编译后执行，存在编译耗时。如果函数无需反复执行，那么Graph Mode加速也可能没有价值。\n",
     "\n",
     "有关使用静态图来进行网络编译的示例，请参考[网络构建](https://www.mindspore.cn/tutorials/zh-CN/master/beginner/model.html)。\n",
     "\n",
     "## 静态图模式开启方式\n",
     "\n",
-    "通常情况下，由于动态图的灵活性，我们会选择使用PyNative模式来进行自由的神经网络构建，以实现模型的创新和优化。但是当需要进行性能加速时，我们需要对神经网络部分或整体进行加速。MindSpore提供了两种切换为图模式的方式，分别是基于装饰器的开启方式以及基于全局context的开启方式。\n",
+    "通常情况下，由于动态图的灵活性，我们会选择使用PyNative模式来进行自由的神经网络构建，以实现模型的创新和优化。但是当需要进行性能加速时，可以对神经网络部分或整体进行加速。MindSpore提供了两种切换为图模式的方式：基于装饰器的开启方式以及基于全局context的开启方式。\n",
     "\n",
     "### 基于装饰器的开启方式\n",
     "\n",
-    "MindSpore提供了jit装饰器，可以通过修饰Python函数或者Python类的成员函数使其被编译成计算图，通过图优化等技术提高运行速度。此时我们可以简单的对想要进行性能优化的模块进行图编译加速，而模型其他部分，仍旧使用解释执行方式，不丢失动态图的灵活性。无论全局context是设置成静态图模式还是动态图模式，被jit修饰的部分始终会以静态图模式进行运行。\n",
+    "MindSpore提供了jit装饰器，可以通过修饰Python函数或者Python类的成员函数使其被编译成计算图，并通过图优化等技术提高运行速度。此时，可以对想要进行性能优化的模块进行图编译加速，而模型其他部分，仍旧使用解释执行方式，不丢失动态图的灵活性。无论全局context是设置成静态图模式还是动态图模式，被jit修饰的部分始终会以静态图模式进行运行。\n",
     "\n",
     "在需要对Tensor的某些运算进行编译加速时，可以在其定义的函数上使用jit修饰器，在调用该函数时，该模块自动被编译为静态图。需要注意的是，jit装饰器只能用来修饰函数，无法对类进行修饰。jit的使用示例如下："
    ]
@@ -457,11 +457,11 @@
    "source": [
     "## 静态图的语法约束\n",
     "\n",
-    "在Graph模式下，Python代码并不是由Python解释器去执行，而是将代码编译成静态计算图，然后执行静态计算图。因此，编译器无法支持全量的Python语法。MindSpore的静态图编译器维护了Python常用语法子集，以支持神经网络的构建及训练。详情可参考[静态图语法支持](https://www.mindspore.cn/tutorials/zh-CN/master/compile/static_graph.html)。\n",
+    "在Graph模式下，Python代码并不会由Python解释器去执行，而是先编译成静态计算图，再执行该静态计算图。因此，编译器无法支持全量的Python语法。MindSpore的静态图编译器支持Python常用语法子集，以支持神经网络的构建及训练。详情可参考[静态图语法支持](https://www.mindspore.cn/tutorials/zh-CN/master/compile/static_graph.html)。\n",
     "\n",
     "## 静态图高级编程技巧\n",
     "\n",
-    "使用静态图高级编程技巧可以有效地提高编译效率以及执行效率，并可以使程序运行更加稳定。详情可参考[静态图高级编程技巧](https://www.mindspore.cn/tutorials/zh-CN/master/compile/static_graph_expert_programming.html)。"
+    "使用静态图高级编程技巧，可以有效地提高编译和执行效率，使程序运行更加稳定。详情可参考[静态图高级编程技巧](https://www.mindspore.cn/tutorials/zh-CN/master/compile/static_graph_expert_programming.html)。"
    ]
   }
  ],
diff --git a/tutorials/source_zh_cn/beginner/autograd.ipynb b/tutorials/source_zh_cn/beginner/autograd.ipynb
index cf6b1256c33f0da18ae829d0e18b942a74283f41..94e8e5691015c9aab853f14d8016fe64db5ced70 100644
--- a/tutorials/source_zh_cn/beginner/autograd.ipynb
+++ b/tutorials/source_zh_cn/beginner/autograd.ipynb
@@ -380,7 +380,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "完成后，由于需要使用函数式自动微分，需要将神经网络和损失函数的调用封装为一个前向计算函数。"
+    "完成后，为使用函数式自动微分，需要将神经网络和损失函数的调用封装为前向计算函数。"
    ]
   },
   {
@@ -402,7 +402,7 @@
    "source": [
     "完成后，我们使用`value_and_grad`接口获得微分函数，用于计算梯度。\n",
     "\n",
-    "由于使用Cell封装神经网络模型，模型参数为Cell的内部属性，此时我们不需要使用`grad_position`指定对函数输入求导，因此将其配置为`None`。对模型参数求导时，我们使用`weights`参数，使用`model.trainable_params()`方法从Cell中取出可以求导的参数。"
+    "由于使用Cell封装神经网络模型，模型参数为Cell的内部属性，此时无需使用`grad_position`指定对函数输入求导，因此将其配置为`None`。对模型参数求导时，使用`weights`参数，通过`model.trainable_params()`方法从Cell中获取可求导参数。"
    ]
   },
   {
diff --git a/tutorials/source_zh_cn/beginner/dataset.ipynb b/tutorials/source_zh_cn/beginner/dataset.ipynb
index a8ca89666a13cf118d9bc43589129aa6b27ee6c6..79b5225838e6c42afdd2dd056f0864ee55e3710f 100644
--- a/tutorials/source_zh_cn/beginner/dataset.ipynb
+++ b/tutorials/source_zh_cn/beginner/dataset.ipynb
@@ -19,9 +19,9 @@
     "\n",
     "数据是深度学习的基础，高质量的数据输入将在整个深度神经网络中起到积极作用。\n",
     "\n",
-    "MindSpore提供基于Pipeline的[数据引擎](https://www.mindspore.cn/docs/zh-CN/master/design/data_engine.html)，通过 `数据集（Dataset）`、`数据变换（Transforms）`和`数据批处理（Batch）`实现高效的数据预处理。其中：\n",
+    "MindSpore提供基于Pipeline的[数据引擎](https://www.mindspore.cn/docs/zh-CN/master/design/data_engine.html)，通过 `数据集（Dataset）`、`数据变换（Transforms）`和`数据批处理（Batch）`，可以实现高效的数据预处理。其中：\n",
     "\n",
-    "1. 数据集（Dataset）是Pipeline的起始，用于从存储中加载原始数据至内存中，`mindspore.dataset`提供了内置的图像、文本、音频等[数据集加载接口](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.loading.html#)，并提供了[自定义数据集加载接口](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.loading.html#%E8%87%AA%E5%AE%9A%E4%B9%89%E6%95%B0%E6%8D%AE%E9%9B%86%E5%8A%A0%E8%BD%BD-1)；\n",
+    "1. 数据集（Dataset）是Pipeline的起始，用于从存储中加载原始数据至内存。`mindspore.dataset`提供了内置的图像、文本、音频等[数据集加载接口](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.loading.html#)，同时支持[自定义数据集加载接口](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.loading.html#%E8%87%AA%E5%AE%9A%E4%B9%89%E6%95%B0%E6%8D%AE%E9%9B%86%E5%8A%A0%E8%BD%BD-1)；\n",
     "\n",
     "2. 数据变换（Transforms）对内存中的数据做进一步的变换操作，`mindspore.dataset.transforms`提供[通用的数据变换操作](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.transforms.html#%E9%80%9A%E7%94%A8)、`mindspore.dataset.transforms.vision`提供[图像数据变换操作](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.transforms.html#%E8%A7%86%E8%A7%89)、`mindspore.dataset.transforms.text`提供[文本数据变换操作](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.transforms.html#%E6%96%87%E6%9C%AC)、`mindspore.dataset.transforms.audio`提供[音频数据变换操作](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.dataset.transforms.html#%E9%9F%B3%E9%A2%91)；\n",
     "\n",
diff --git a/tutorials/source_zh_cn/beginner/introduction.ipynb b/tutorials/source_zh_cn/beginner/introduction.ipynb
index 83353916c608310ed417ac56780a58b015229d85..c801892b0d12333e3af540ddca9009a294b3b0b7 100644
--- a/tutorials/source_zh_cn/beginner/introduction.ipynb
+++ b/tutorials/source_zh_cn/beginner/introduction.ipynb
@@ -19,7 +19,7 @@
    "source": [
     "# 基本介绍\n",
     "\n",
-    "本节将会整体介绍昇思MindSpore和华为昇腾AI全栈，并介绍昇思MindSpore在华为昇腾AI全栈中的位置。对昇思MindSpore感兴趣的开发者，最后可以参与昇思MindSpore的[社区](https://gitee.com/mindspore/mindspore)并一键三连[（Watch/Star/Fork）](https://gitee.com/mindspore/mindspore)。\n",
+    "本节将会整体介绍昇思MindSpore和华为昇腾AI全栈，并介绍昇思MindSpore在华为昇腾AI全栈中的位置。对昇思MindSpore感兴趣的开发者，欢迎参与昇思MindSpore的[社区](https://gitee.com/mindspore/mindspore)并一键三连[（Watch/Star/Fork）](https://gitee.com/mindspore/mindspore)。\n",
     "\n",
     "## 昇思MindSpore介绍\n",
     "\n",
@@ -49,10 +49,10 @@
     "\n",
     "下面简单介绍每个模块的作用：\n",
     "\n",
-    "- **昇腾应用使能**：华为各大产品线基于MindSpore提供的AI平台或服务能力\n",
-    "- **MindSpore**：支持端、边、云独立的和协同的统一训练和推理框架\n",
+    "- **昇腾应用使能**：华为各大产品线基于MindSpore提供的AI平台或服务能力。\n",
+    "- **MindSpore**：支持端、边、云独立和协同的统一训练和推理框架。\n",
     "- **CANN**：昇腾芯片使能、驱动层（[了解更多](https://www.hiascend.com/zh/software/cann)）。\n",
-    "- **计算资源**：昇腾系列化IP、芯片和服务器\n",
+    "- **计算资源**：昇腾系列化IP、芯片和服务器。\n",
     "\n",
     "详细信息请点击[华为昇腾官网](https://e.huawei.com/cn/products/servers/ascend)。\n",
     "\n",
@@ -65,7 +65,7 @@
     "\n",
     "    - [MindSpore Gitee](https://gitee.com/mindspore/mindspore)：2020年Gitee千万开源项目中Gitee指数TOP1项目，一键三连（Watch/Star/Fork）即可随时跟踪MindSpore最新进展，参与issues讨论、提交代码！\n",
     "\n",
-    "    - [MindSpore GitHub](https://github.com/mindspore-ai/mindspore)：Gitee的MindSpore代码镜像，习惯用GitHub的开发者可以在这里进行MindSpore的学习，查看最新代码实现！\n",
+    "    - [MindSpore GitHub](https://github.com/mindspore-ai/mindspore)：Gitee的MindSpore代码镜像，习惯用GitHub的开发者可以在这里学习MindSpore，查看最新代码实现！\n",
     "\n",
     "- **昇思MindSpore 论坛**：我们努力地服务好每一个开发者，在昇思MindSpore中，无论是入门开发者还是高手大咖都能找到知音，共同学习，共同成长！（[了解更多](https://discuss.mindspore.cn/)）"
    ]
diff --git a/tutorials/source_zh_cn/beginner/mixed_precision.ipynb b/tutorials/source_zh_cn/beginner/mixed_precision.ipynb
index 0c640f3e07d1254d672817bdcf32219d46c9f1c8..ecbf71dd0035ca1c2a953b5f03ab58669339f27b 100644
--- a/tutorials/source_zh_cn/beginner/mixed_precision.ipynb
+++ b/tutorials/source_zh_cn/beginner/mixed_precision.ipynb
@@ -19,9 +19,9 @@
    "source": [
     "混合精度（Mix Precision）训练是指在训练时，对神经网络不同的运算采用不同的数值精度的运算策略。在神经网络运算中，部分运算对数值精度不敏感，此时使用较低精度可以达到明显的加速效果（如conv、matmul等）；而部分运算由于输入和输出的数值差异大，通常需要保留较高精度以保证结果的正确性（如log、softmax等）。\n",
     "\n",
-    "当前的AI加速卡通常通过针对计算密集、精度不敏感的运算设计了硬件加速模块，如NVIDIA GPU的TensorCore、Ascend NPU的Cube等。对于conv、matmul等运算占比较大的神经网络，其训练速度通常会有较大的加速比。\n",
+    "当前的AI加速卡通常针对计算密集、精度不敏感的运算设计了硬件加速模块，如NVIDIA GPU的TensorCore、Ascend NPU的Cube等。对于conv、matmul等运算占比较大的神经网络，其训练速度通常会有较大的加速比。\n",
     "\n",
-    "`mindspore.amp`模块提供了便捷的自动混合精度接口，用户可以在不同的硬件后端通过简单的接口调用获得训练加速。下面我们对混合精度计算原理进行简介，而后通过实例介绍MindSpore的自动混合精度用法。"
+    "`mindspore.amp`模块提供了便捷的自动混合精度接口，用户可以在不同的硬件后端通过简单的接口调用获得训练加速。下面我们简要介绍混合精度计算原理，并通过实例介绍MindSpore的自动混合精度用法。"
    ]
   },
   {
@@ -37,24 +37,24 @@
    "id": "76ebb0cf-7c2d-49d4-8905-04d928567e76",
    "metadata": {},
    "source": [
-    "浮点数据类型主要分为双精度（FP64）、单精度（FP32）、半精度（FP16）。在神经网络模型的训练过程中，一般默认采用单精度（FP32）浮点数据类型，来表示网络模型权重和其他参数。在了解混合精度训练之前，这里简单了解浮点数据类型。\n",
+    "浮点数据类型主要分为双精度（FP64）、单精度（FP32）、半精度（FP16）。在神经网络模型的训练过程中，一般默认采用单精度（FP32）浮点数据类型，来表示网络模型权重和其他参数。在了解混合精度训练之前，先简单了解浮点数据类型。\n",
     "\n",
-    "根据IEEE二进制浮点数算术标准（[IEEE 754](https://en.wikipedia.org/wiki/IEEE_754)）的定义，浮点数据类型分为双精度（FP64）、单精度（FP32）、半精度（FP16）三种，其中每一种都有三个不同的部分来表示。FP64表示采用8个字节共64位，来进行的编码存储的一种数据类型；同理，FP32表示采用4个字节共32位来表示；FP16则是采用2字节共16位来表示。如图所示：\n",
+    "根据IEEE二进制浮点数算术标准（[IEEE 754](https://en.wikipedia.org/wiki/IEEE_754)）的定义，浮点数据类型分为双精度（FP64）、单精度（FP32）、半精度（FP16）三种。每一种都有三个不同的部分来表示。FP64采用8个字节共64位进行编码存储；FP32采用4个字节共32位；FP16则是采用2字节共16位。如图所示：\n",
     "\n",
     "![fp16-vs-fp32](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/tutorials/source_zh_cn/beginner/images/fp16_vs_fp32.png)\n",
     "\n",
     "从图中可以看出，与FP32相比，FP16的存储空间是FP32的一半。类似地，FP32则是FP64的一半。因此使用FP16进行运算具备以下优势：\n",
     "\n",
-    "- 减少内存占用：FP16的位宽是FP32的一半，因此权重等参数所占用的内存也是原来的一半，节省下来的内存可以放更大的网络模型或者使用更多的数据进行训练。\n",
-    "- 计算效率更高：在特殊的AI加速芯片如华为Atlas训练系列产品和Atlas 200/300/500推理产品系列，或者NVIDIA VOLTA架构的GPU上，使用FP16的执行运算性能比FP32更加快。\n",
-    "- 加快通讯效率：针对分布式训练，特别是在大模型训练的过程中，通讯的开销制约了网络模型训练的整体性能，通讯的位宽少了意味着可以提升通讯性能，减少等待时间，加快数据的流通。\n",
+    "- 减少内存占用：FP16的位宽是FP32的一半，因此权重等参数所占用的内存也是原来的一半，节省下来的内存可以用于更大的网络模型或者更多的数据训练。\n",
+    "- 计算效率更高：在特殊的AI加速芯片（如华为Atlas训练系列、Atlas 200/300/500推理系列，或NVIDIA VOLTA架构的GPU）上，FP16运算性能比FP32更高。\n",
+    "- 加快通讯效率：针对分布式训练，特别是在大模型训练的过程中，通讯的开销制约了网络模型训练的整体性能。通讯的位宽减少可提升通讯性能，减少等待时间，加快数据的流通。\n",
     "\n",
     "但是使用FP16同样会带来一些问题：\n",
     "\n",
     "- 数据溢出：FP16的有效数据表示范围为 $[5.9\\times10^{-8}, 65504]$，FP32的有效数据表示范围为 $[1.4\\times10^{-45}, 1.7\\times10^{38}]$。可见FP16相比FP32的有效范围要窄很多，使用FP16替换FP32会出现上溢（Overflow）和下溢（Underflow）的情况。而在深度学习中，需要计算网络模型中权重的梯度（一阶导数），因此梯度会比权重值更加小，往往容易出现下溢情况。\n",
     "- 舍入误差：Rounding Error是指当网络模型的反向梯度很小，一般FP32能够表示，但是转换到FP16会小于当前区间内的最小间隔，会导致数据溢出。如`0.00006666666`在FP32中能正常表示，转换到FP16后会表示成为`0.000067`，不满足FP16最小间隔的数会强制舍入。\n",
     "\n",
-    "因此，在使用混合精度获得训练加速和内存节省的同时，需要考虑FP16引入问题的解决。Loss Scale损失缩放，FP16类型数据下溢问题的解决方案，其主要思想是在计算损失值loss的时候，将loss扩大一定的倍数。根据链式法则，梯度也会相应扩大，然后在优化器更新权重时再缩小相应的倍数，从而避免了数据下溢。"
+    "因此，在使用混合精度获得训练加速和内存节省的同时，需要考虑FP16带来的问题。Loss Scale（损失缩放）是FP16类型数据下溢问题的解决方案，其主要思想是在计算损失值loss的时候，将loss扩大一定的倍数。根据链式法则，梯度也会相应扩大，然后在优化器更新权重时再缩小相应的倍数，从而避免数据下溢。"
    ]
   },
   {
@@ -203,7 +203,7 @@
    "source": [
     "### 手动类型转换\n",
     "\n",
-    "通常情况下自动类型转换可以通过满足大部分混合精度训练的需求，但当用户需要精细化控制神经网络不同部分的运算精度时，可以通过手动类型转换的方式进行控制。\n",
+    "通常情况下，自动类型转换可以满足大部分混合精度训练的需求。但当用户需要精细化控制神经网络不同部分的运算精度时，可以通过手动类型转换的方式来实现。\n",
     "\n",
     "> 手动类型转换需考虑模型各个模块的运算精度，一般仅在需要获得极致性能的情况下使用。\n",
     "\n",
diff --git a/tutorials/source_zh_cn/beginner/model.ipynb b/tutorials/source_zh_cn/beginner/model.ipynb
index a5164e1faecda58a3fd0c58da1720829c4085912..0bc8993acdfd9c29d90d4935ee6959e613e88d50 100644
--- a/tutorials/source_zh_cn/beginner/model.ipynb
+++ b/tutorials/source_zh_cn/beginner/model.ipynb
@@ -20,7 +20,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "神经网络模型是由神经网络层和Tensor操作构成的，[mindspore.nn](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.nn.html)提供了常见神经网络层的实现。在MindSpore中，[Cell](https://www.mindspore.cn/docs/zh-CN/master/api_python/nn/mindspore.nn.Cell.html)类是构建所有网络的基类，也是网络的基本单元。一个神经网络模型表示为一个`Cell`，它由不同的子`Cell`构成。使用这样的嵌套结构，可以简单地使用面向对象编程的思维，对神经网络结构进行构建和管理。\n",
+    "神经网络模型由神经网络层和Tensor操作构成，[mindspore.nn](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore.nn.html)提供了常见神经网络层的实现。在MindSpore中，[Cell](https://www.mindspore.cn/docs/zh-CN/master/api_python/nn/mindspore.nn.Cell.html)类是构建所有网络的基类，也是网络的基本单元。一个神经网络模型可表示为一个`Cell`，由不同的子`Cell`构成。使用这样的嵌套结构，可以简单地使用面向对象编程的思维，对神经网络结构进行构建和管理。\n",
     "\n",
     "下面我们将构建一个用于Mnist数据集分类的神经网络模型。"
    ]
@@ -161,7 +161,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "在此基础上，我们通过一个`nn.Softmax`层实例来获得预测概率。"
+    "在此基础上，通过一个`nn.Softmax`层实例获得预测概率。"
    ]
   },
   {
@@ -193,7 +193,7 @@
    "source": [
     "## 模型层\n",
     "\n",
-    "本节中我们分解上节构造的神经网络模型中的每一层。首先我们构造一个shape为(3, 28, 28)的随机数据（3个28x28的图像），依次通过每一个神经网络层来观察其效果。"
+    "本节将分解上节构造的神经网络模型中的每一层。首先，构造一个shape为(3, 28, 28)的随机数据（即3个28x28的图像），依次通过每个神经网络层来观察其效果。"
    ]
   },
   {
@@ -299,7 +299,7 @@
    "source": [
     "### nn.ReLU\n",
     "\n",
-    "[nn.ReLU](https://www.mindspore.cn/docs/zh-CN/master/api_python/nn/mindspore.nn.ReLU.html)层给网络中加入非线性的激活函数，帮助神经网络学习各种复杂的特征。"
+    "[nn.ReLU](https://www.mindspore.cn/docs/zh-CN/master/api_python/nn/mindspore.nn.ReLU.html)层为网络加入非线性激活函数，帮助神经网络学习各种复杂的特征。"
    ]
   },
   {
@@ -401,7 +401,7 @@
    "source": [
     "### nn.Softmax\n",
     "\n",
-    "最后使用[nn.Softmax](https://www.mindspore.cn/docs/zh-CN/master/api_python/nn/mindspore.nn.Softmax.html)将神经网络最后一个全连接层返回的logits的值缩放为\\[0, 1\\]，表示每个类别的预测概率。`axis`指定的维度数值和为1。"
+    "最后使用[nn.Softmax](https://www.mindspore.cn/docs/zh-CN/master/api_python/nn/mindspore.nn.Softmax.html)将神经网络最后一个全连接层返回的logits的值缩放到\\[0, 1\\]区间，表示每个类别的预测概率。`axis`指定的维度数值和为1。"
    ]
   },
   {
diff --git a/tutorials/source_zh_cn/beginner/quick_start.ipynb b/tutorials/source_zh_cn/beginner/quick_start.ipynb
index f03b21eb7424f0194a84f75eee9c418e7416c248..82f58972ca2be322574828329ff4e2519dda825e 100644
--- a/tutorials/source_zh_cn/beginner/quick_start.ipynb
+++ b/tutorials/source_zh_cn/beginner/quick_start.ipynb
@@ -221,7 +221,7 @@
    "source": [
     "## 网络构建\n",
     "\n",
-    "`mindspore.nn`类是构建所有网络的基类，也是网络的基本单元。当用户需要自定义网络时，可以继承`nn.Cell`类，并重写`__init__`方法和`construct`方法。`__init__`包含所有网络层的定义，`construct`中包含数据（[Tensor](https://www.mindspore.cn/tutorials/zh-CN/master/beginner/tensor.html)）的变换过程。"
+    "`mindspore.nn`类是构建所有网络的基类，也是网络的基本单元。当用户需要自定义网络时，可以继承`nn.Cell`类，并重写`__init__`方法和`construct`方法。`__init__`包含所有网络层的定义，`construct`包含数据（[Tensor](https://www.mindspore.cn/tutorials/zh-CN/master/beginner/tensor.html)）的变换过程。"
    ]
   },
   {
@@ -289,8 +289,8 @@
    "source": [
     "在模型训练中，一个完整的训练过程（step）需要实现以下三步：\n",
     "\n",
-    "1. **正向计算**：模型预测结果（logits），并与正确标签（label）求预测损失（loss）。\n",
-    "2. **反向传播**：利用自动微分机制，自动求模型参数（parameters）对于loss的梯度（gradients）。\n",
+    "1. **正向计算**：模型输出预测结果（logits），并与正确标签（label）计算预测损失（loss）。\n",
+    "2. **反向传播**：利用自动微分机制，自动计算模型参数（parameters）对loss的梯度（gradients）。\n",
     "3. **参数优化**：将梯度更新到参数上。"
    ]
   },
@@ -455,7 +455,7 @@
    "source": [
     "## 保存模型\n",
     "\n",
-    "模型训练完成后，需要将其参数进行保存。"
+    "模型训练完成后，需要保存其参数。"
    ]
   },
   {
@@ -520,7 +520,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "> `param_not_load`是未被加载的参数列表，为空时代表所有参数均加载成功。"
+    "> `param_not_load`是未被加载的参数列表。为空时，表示所有参数均加载成功。"
    ]
   },
   {
diff --git a/tutorials/source_zh_cn/beginner/tensor.ipynb b/tutorials/source_zh_cn/beginner/tensor.ipynb
index 2ef5820cfc80cb5b0211e5d56cc88f927113d237..9a6696bad5195551ef037fa531ed550000dbb1eb 100644
--- a/tutorials/source_zh_cn/beginner/tensor.ipynb
+++ b/tutorials/source_zh_cn/beginner/tensor.ipynb
@@ -18,7 +18,7 @@
    "source": [
     "# 张量 Tensor\n",
     "\n",
-    "张量（Tensor）是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数，这些线性关系的基本例子有内积、外积、线性映射以及笛卡儿积。其坐标在 $n$ 维空间内，有  $n^{r}$ 个分量的一种量，其中每个分量都是坐标的函数，而在坐标变换时，这些分量也依照某些规则作线性变换。$r$ 称为该张量的秩或阶（与矩阵的秩和阶均无关系）。\n",
+    "张量（Tensor）是一个多线性函数，可用于表示矢量、标量和其他张量之间的线性关系。常见的线性关系包括内积、外积、线性映射以及笛卡儿积等。张量的坐标在 $n$ 维空间内，有  $n^{r}$ 个分量，每个分量都是坐标的函数。在坐标变换时，这些分量也依照某些规则作线性变换。$r$ 称为该张量的秩或阶（与矩阵的秩和阶无关）。\n",
     "\n",
     "张量是一种特殊的数据结构，与数组和矩阵非常相似。张量（[Tensor](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.Tensor.html)）是MindSpore网络运算中的基本数据结构，本教程主要介绍张量的属性及用法。"
    ]
@@ -45,7 +45,7 @@
     "\n",
     "- **根据数据直接生成**\n",
     "\n",
-    "    可以根据数据创建张量，数据类型可以设置或者通过框架自动推断。"
+    "    可以根据数据创建张量。数据类型可以手动设置，也可以由框架自动推断。"
    ]
   },
   {
@@ -144,7 +144,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "`init`主要用于并行模式下的延后初始化，在正常情况下不建议使用init对参数进行初始化。\n",
+    "`init`主要用于并行模式下的延后初始化。在正常情况下，不建议使用init对参数进行初始化。\n",
     "\n",
     "- **继承另一个张量的属性，形成新的张量**"
    ]
@@ -185,19 +185,19 @@
     "\n",
     "张量的属性包括形状、数据类型、转置张量、单个元素大小、占用字节数量、维数、元素个数和每一维步长。\n",
     "\n",
-    "- 形状（shape）：`Tensor`的shape，是一个tuple。\n",
+    "- 形状（shape）：`Tensor`的shape，为tuple类型。\n",
     "\n",
     "- 数据类型（dtype）：`Tensor`的dtype，是MindSpore的一个数据类型。\n",
     "\n",
-    "- 单个元素大小（itemsize）： `Tensor`中每一个元素占用字节数，是一个整数。\n",
+    "- 单个元素大小（itemsize）： `Tensor`中每一个元素占用字节数，为整数类型。\n",
     "\n",
-    "- 占用字节数量（nbytes）： `Tensor`占用的总字节数，是一个整数。\n",
+    "- 占用字节数量（nbytes）： `Tensor`占用的总字节数，为整数类型。\n",
     "\n",
-    "- 维数（ndim）： `Tensor`的秩，也就是len(tensor.shape)，是一个整数。\n",
+    "- 维数（ndim）： `Tensor`的秩，也就是len(tensor.shape)，为整数类型。\n",
     "\n",
-    "- 元素个数（size）： `Tensor`中所有元素的个数，是一个整数。\n",
+    "- 元素个数（size）： `Tensor`中所有元素的个数，为整数类型。\n",
     "\n",
-    "- 每一维步长（strides）： `Tensor`每一维所需要的字节数，是一个tuple。"
+    "- 每一维步长（strides）： `Tensor`每一维所需要的字节数，为tuple类型。"
    ]
   },
   {
@@ -237,7 +237,7 @@
    "source": [
     "## 张量索引\n",
     "\n",
-    "Tensor索引与Numpy索引类似，索引从0开始编制，负索引表示按倒序编制，冒号`:`和 `...`用于对数据进行切片。"
+    "Tensor索引与Numpy索引类似。索引从0开始编制，负索引表示按倒序编制。冒号`:`和 `...`用于对数据进行切片。"
    ]
   },
   {
@@ -271,9 +271,9 @@
    "source": [
     "## 张量运算\n",
     "\n",
-    "张量之间有很多运算，包括算术、线性代数、矩阵处理（转置、标引、切片）、采样等。张量运算和NumPy的使用方式类似，下面介绍其中几种操作。\n",
+    "张量之间有很多运算，包括算术、线性代数、矩阵处理（转置、标引、切片）、采样等。张量运算的使用方式和NumPy类似，下面介绍其中几种操作。\n",
     "\n",
-    "> 普通算术运算有：加（+）、减（-）、乘（\\*）、除（/）、取模（%）、整除（//）。"
+    "> 普通算术运算包括：加（+）、减（-）、乘（\\*）、除（/）、取模（%）、整除（//）。"
    ]
   },
   {
@@ -392,7 +392,7 @@
     "\n",
     "### Tensor转换为NumPy\n",
     "\n",
-    "与张量创建相同，使用 [Tensor.asnumpy()](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/Tensor/mindspore.Tensor.asnumpy.html) 将Tensor变量转换为NumPy变量。"
+    "可以使用 [Tensor.asnumpy()](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/Tensor/mindspore.Tensor.asnumpy.html) 将Tensor变量转换为NumPy变量。"
    ]
   },
   {
diff --git a/tutorials/source_zh_cn/beginner/train.ipynb b/tutorials/source_zh_cn/beginner/train.ipynb
index 9e434cc218aebdfcd9c6add24589f23aead81544..3c5df84a60879bf739810d5fc75243ecfa1eb7c4 100644
--- a/tutorials/source_zh_cn/beginner/train.ipynb
+++ b/tutorials/source_zh_cn/beginner/train.ipynb
@@ -154,7 +154,7 @@
     "\n",
     "### 超参\n",
     "\n",
-    "超参（Hyperparameters）是可以调整的参数，可以控制模型训练优化的过程，不同的超参数值可能会影响模型训练和收敛速度。目前深度学习模型多采用批量随机梯度下降算法进行优化，随机梯度下降算法的原理如下：\n",
+    "超参（Hyperparameters）是可以调整的参数，可以控制模型训练优化的过程，不同的超参数值可能会影响模型训练和收敛速度。目前深度学习模型多采用批量随机梯度下降算法进行优化，其原理如下：\n",
     "\n",
     "$$w_{t+1}=w_{t}-\\eta \\frac{1}{n} \\sum_{x \\in \\mathcal{B}} \\nabla l\\left(x, w_{t}\\right)$$\n",
     "\n",
@@ -162,9 +162,9 @@
     "\n",
     "- **训练轮次（epoch）**：训练时遍历数据集的次数。\n",
     "\n",
-    "- **批次大小（batch size）**：数据集进行分批读取训练，设定每个批次数据的大小。batch size过小，花费时间多，同时梯度震荡严重，不利于收敛；batch size过大，不同batch的梯度方向没有任何变化，容易陷入局部极小值，因此需要选择合适的batch size，可以有效提高模型精度、全局收敛。\n",
+    "- **批次大小（batch size）**：数据集进行分批读取训练，设定每个批次数据的大小。batch size过小，训练时间较长，且梯度震荡严重，不利于收敛；batch size过大，不同batch的梯度方向变化小，容易陷入局部极小值。因此，选择合适的batch size，可以有效提高模型精度和全局收敛性。\n",
     "\n",
-    "- **学习率（learning rate）**：如果学习率偏小，会导致收敛的速度变慢，如果学习率偏大，则可能会导致训练不收敛等不可预测的结果。梯度下降法被广泛应用在最小化模型误差的参数优化算法上。梯度下降法通过多次迭代，并在每一步中最小化损失函数来预估模型的参数。学习率就是在迭代过程中，会控制模型的学习进度。"
+    "- **学习率（learning rate）**：学习率偏小，会导致收敛的速度变慢；学习率偏大，则可能会导致训练不收敛等不可预测的结果。梯度下降法被广泛应用在最小化模型误差的参数优化算法上。通过多次迭代，并在每一步中最小化损失函数来预估模型的参数。学习率用于控制模型在迭代过程中的学习进度。"
    ]
   },
   {
@@ -263,12 +263,12 @@
    "source": [
     "## 训练与评估\n",
     "\n",
-    "设置了超参、损失函数和优化器后，我们就可以循环输入数据来训练模型。一次数据集的完整迭代循环称为一轮（epoch）。每轮执行训练时包括两个步骤：\n",
+    "设置了超参、损失函数和优化器后，我们就可以循环输入数据来训练模型。完整遍历一次数据集称为一轮（epoch）。每轮训练包括两个步骤：\n",
     "\n",
     "1. 训练：迭代训练数据集，并尝试收敛到最佳参数。\n",
     "2. 验证/测试：迭代测试数据集，以检查模型性能是否提升。\n",
     "\n",
-    "接下来我们定义用于训练的`train_loop`函数和用于测试的`test_loop`函数。"
+    "接下来，定义用于训练的`train_loop`函数和用于测试的`test_loop`函数。"
    ]
   },
   {
@@ -279,7 +279,7 @@
     }
    },
    "source": [
-    "使用函数式自动微分，需先定义正向函数`forward_fn`，使用[value_and_grad](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.value_and_grad.html)获得微分函数`grad_fn`。然后，我们将微分函数和优化器的执行封装为`train_step`函数，接下来循环迭代数据集进行训练即可。"
+    "使用函数式自动微分，需先定义正向函数`forward_fn`，再使用[value_and_grad](https://www.mindspore.cn/docs/zh-CN/master/api_python/mindspore/mindspore.value_and_grad.html)获取微分函数`grad_fn`。然后，我们将微分函数和优化器的执行封装为`train_step`函数，最后循环迭代数据集进行训练。"
    ]
   },
   {
@@ -326,7 +326,7 @@
     }
    },
    "source": [
-    "`test_loop`函数同样需循环遍历数据集，调用模型计算loss和Accuray并返回最终结果。"
+    "`test_loop`函数同样需循环遍历数据集，调用模型计算loss和Accuray，并返回最终结果。"
    ]
   },
   {
@@ -361,7 +361,7 @@
     }
    },
    "source": [
-    "我们将实例化的损失函数和优化器传入`train_loop`和`test_loop`中。训练3轮并输出loss和Accuracy，查看性能变化。"
+    "我们将实例化的损失函数和优化器传入`train_loop`和`test_loop`中。训练3轮，并输出loss和Accuracy，观察性能变化。"
    ]
   },
   {