diff --git a/docs/api/api_python/mindarmour.adv_robustness.attacks.rst b/docs/api/api_python/mindarmour.adv_robustness.attacks.rst
index ef22688..4c7523f 100644
--- a/docs/api/api_python/mindarmour.adv_robustness.attacks.rst
+++ b/docs/api/api_python/mindarmour.adv_robustness.attacks.rst
@@ -1,11 +1,11 @@
 mindarmour.adv_robustness.attacks
 =================================
 
-本模块包括经典的黑盒和白盒攻击算法，以制作对抗性示例。
+本模块包括经典的黑盒和白盒攻击算法，以制作对抗样本。
 
 .. py:class:: mindarmour.adv_robustness.attacks.FastGradientMethod(network, eps=0.07, alpha=None, bounds=(0.0, 1.0), norm_level=2, is_targeted=False, loss_fn=None)
 
-    这种攻击是基于梯度计算的单步攻击，扰动的范数包括 'L1'、'L2'和'Linf'。
+    基于梯度计算的单步攻击，扰动的范数包括 'L1'、'L2'和'Linf'。
 
     参考文献：`I. J. Goodfellow, J. Shlens, and C. Szegedy, "Explaining and harnessing adversarial examples," in ICLR, 2015. <https://arxiv.org/abs/1412.6572>`_。
 
@@ -13,16 +13,17 @@ mindarmour.adv_robustness.attacks
 
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.07。
-    - **alpha** (float) - 单步随机扰动与数据范围的比例。默认值：None。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
-    - **norm_level** (Union[int, numpy.inf]) - 范数的顺序。可取值：np.inf、1或2。默认值：2。
+    - **alpha** (Union[float, None]) - 单步随机扰动与数据范围的比例。默认值：None。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值, 数据最大值)的形式出现。默认值：(0.0, 1.0)。
+    - **norm_level** (Union[int, str, numpy.inf]) - 范数类型。
+      可取值：numpy.inf、1、2、'1'、'2'、'l1'、'l2'、'np.inf'、'inf'、'linf'。默认值：2。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **loss_fn** (Union[loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
 .. py:class:: mindarmour.adv_robustness.attacks.RandomFastGradientMethod(network, eps=0.07, alpha=0.035, bounds=(0.0, 1.0), norm_level=2, is_targeted=False, loss_fn=None)
 
-    快速梯度法（Fast Gradient Method）使用随机扰动。
-    基于梯度计算的单步攻击。对抗性噪声是根据输入的梯度生成的，然后随机扰动。
+    使用随机扰动的快速梯度法（Fast Gradient Method）。
+    基于梯度计算的单步攻击，其对抗性噪声是根据输入的梯度生成的，然后加入随机扰动，从而生成对抗样本。
 
     参考文献：`Florian Tramer, Alexey Kurakin, Nicolas Papernot, "Ensemble adversarial training: Attacks and defenses" in ICLR, 2018 <https://arxiv.org/abs/1705.07204>`_。
 
@@ -31,10 +32,11 @@ mindarmour.adv_robustness.attacks
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.07。
     - **alpha** (float) - 单步随机扰动与数据范围的比例。默认值：0.035。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
-    - **norm_level** (Union[int, numpy.inf]) - 范数的顺序。可取值：np.inf、1或2。默认值：2。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
+    - **norm_level** (Union[int, str, numpy.inf]) - 范数类型。
+      可取值：numpy.inf、1、2、'1'、'2'、'l1'、'l2'、'np.inf'、'inf'、'linf'。默认值：2。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **loss_fn** (Union[loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
     **异常：**
 
@@ -42,7 +44,7 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.FastGradientSignMethod(network, eps=0.07, alpha=None, bounds=(0.0, 1.0), is_targeted=False, loss_fn=None)
 
-    快速梯度符号法（Fast Gradient Sign Method）攻击计算输入数据的梯度，然后使用梯度的符号创建对抗性噪声。
+    快速梯度下降法（Fast Gradient Sign Method）攻击计算输入数据的梯度，然后使用梯度的符号创建对抗性噪声。
 
     参考文献：`Ian J. Goodfellow, J. Shlens, and C. Szegedy, "Explaining and harnessing adversarial examples," in ICLR, 2015 <https://arxiv.org/abs/1412.6572>`_。
 
@@ -50,14 +52,14 @@ mindarmour.adv_robustness.attacks
 
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.07。
-    - **alpha** (float) - 单步随机扰动与数据范围的比例。默认值：None。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **alpha** (Union[float, None]) - 单步随机扰动与数据范围的比例。默认值：None。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
 .. py:class:: mindarmour.adv_robustness.attacks.RandomFastGradientSignMethod(network, eps=0.07, alpha=0.035, bounds=(0.0, 1.0), is_targeted=False, loss_fn=None)
 
-    快速梯度符号法（Fast Gradient Sign Method）使用随机扰动。
+    快速梯度下降法（Fast Gradient Sign Method）使用随机扰动。
     随机快速梯度符号法（Random Fast Gradient Sign Method）攻击计算输入数据的梯度，然后使用带有随机扰动的梯度符号来创建对抗性噪声。
 
     参考文献：`F. Tramer, et al., "Ensemble adversarial training: Attacks and defenses," in ICLR, 2018 <https://arxiv.org/abs/1705.07204>`_。
@@ -67,10 +69,9 @@ mindarmour.adv_robustness.attacks
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.07。
     - **alpha** (float) - 单步随机扰动与数据范围的比例。默认值：0.005。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。
-      以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
     **异常：**
 
@@ -86,9 +87,9 @@ mindarmour.adv_robustness.attacks
 
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.07。
-    - **alpha** (float) - 单步随机扰动与数据范围的比例。默认值：None。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **alpha** (Union[float, None]) - 单步随机扰动与数据范围的比例。默认值：None。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
 .. py:class:: mindarmour.adv_robustness.attacks.RandomLeastLikelyClassMethod(network, eps=0.07, alpha=0.035, bounds=(0.0, 1.0), loss_fn=None)
 
@@ -103,8 +104,8 @@ mindarmour.adv_robustness.attacks
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.07。
     - **alpha** (float) - 单步随机扰动与数据范围的比例。默认值：0.005。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
     **异常：**
 
@@ -119,9 +120,9 @@ mindarmour.adv_robustness.attacks
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的对抗性扰动占数据范围的比例。默认值：0.3。
     - **eps_iter** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.1。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **nb_iter** (int) - 迭代次数。默认值：5。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
     .. py:method:: generate(inputs, labels)
 
@@ -129,7 +130,7 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, tuple]) - 用作创建对抗样本的引用的良性输入样本。
+        - **inputs** (Union[numpy.ndarray, tuple]) - 良性输入样本，用于创建对抗样本。
         - **labels** (Union[numpy.ndarray, tuple]) - 原始/目标标签。若每个输入有多个标签，将它包装在元组中。
 
         **异常：**
@@ -138,6 +139,8 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.BasicIterativeMethod(network, eps=0.3, eps_iter=0.1, bounds=(0.0, 1.0), is_targeted=False, nb_iter=5, loss_fn=None)
 
+    基本迭代法（Basic Iterative Method）攻击，一种生成对抗示例的迭代FGSM方法。
+
     参考文献：`A. Kurakin, I. Goodfellow, and S. Bengio, "Adversarial examples in the physical world," in ICLR, 2017 <https://arxiv.org/abs/1607.02533>`_。
 
     **参数：**
@@ -145,18 +148,18 @@ mindarmour.adv_robustness.attacks
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的对抗性扰动占数据范围的比例。默认值：0.3。
     - **eps_iter** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.1。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
     - **nb_iter** (int) - 迭代次数。默认值：5。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
     .. py:method:: generate(inputs, labels)    
 
-        简单的迭代FGSM方法生成对抗样本。
+        使用迭代FGSM方法生成对抗样本。
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, tuple]) - 用作创建对抗样本的引用的良性输入样本。
+        - **inputs** (Union[numpy.ndarray, tuple]) - 良性输入样本，用于创建对抗样本。
         - **labels** (Union[numpy.ndarray, tuple]) - 原始/目标标签。若每个输入有多个标签，将它包装在元组中。
 
         **返回：**
@@ -165,7 +168,7 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.MomentumIterativeMethod(network, eps=0.3, eps_iter=0.1, bounds=(0.0, 1.0), is_targeted=False, nb_iter=5, decay_factor=1.0, norm_level='inf', loss_fn=None)
 
-    动量迭代法（Momentum Iterative Method）攻击通过在迭代中积累损失函数梯度方向上的速度矢量，加速梯度下降算法，如FGSM、FGM和LLCM，从而生成对抗样本。
+    动量迭代法（Momentum Iterative Method）攻击，通过在迭代中积累损失函数的梯度方向上的速度矢量，加速梯度下降算法，如FGSM、FGM和LLCM，从而生成对抗样本。
 
     参考文献：`Y. Dong, et al., "Boosting adversarial attacks with momentum," arXiv:1710.06081, 2017 <https://arxiv.org/abs/1710.06081>`_。
 
@@ -175,12 +178,13 @@ mindarmour.adv_robustness.attacks
     - **eps** (float) - 攻击产生的对抗性扰动占数据范围的比例。默认值：0.3。
     - **eps_iter** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.1。
     - **bounds** (tuple) - 数据的上下界，表示数据范围。
-      以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+      以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
     - **nb_iter** (int) - 迭代次数。默认值：5。
     - **decay_factor** (float) - 迭代中的衰变因子。默认值：1.0。
-    - **norm_level** (Union[int, numpy.inf]) - 范数的顺序。可取值：np.inf、1或2。默认值：'inf'。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **norm_level** (Union[int, str, numpy.inf]) - 范数类型。
+      可取值：numpy.inf、1、2、'1'、'2'、'l1'、'l2'、'np.inf'、'inf'、'linf'。默认值：numpy.inf。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
     .. py:method:: generate(inputs, labels)    
 
@@ -188,7 +192,7 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, tuple]) - 用作创建对抗样本的引用的良性输入样本。
+        - **inputs** (Union[numpy.ndarray, tuple]) - 良性输入样本，用于创建对抗样本。
         - **labels** (Union[numpy.ndarray, tuple]) - 原始/目标标签。若每个输入有多个标签，将它包装在元组中。
 
         **返回：**
@@ -197,7 +201,7 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.ProjectedGradientDescent(network, eps=0.3, eps_iter=0.1, bounds=(0.0, 1.0), is_targeted=False, nb_iter=5, norm_level='inf', loss_fn=None)
 
-    投影梯度下降（Projected Gradient Descent）攻击是基本迭代法的变体，在这种方法中，在每次迭代之后，扰动被投影在指定半径的p范数球上（除了剪切对抗样本的值，使其位于允许的数据范围内）。这是Madry等人提出的用于对抗性训练的攻击。
+    投影梯度下降（Projected Gradient Descent）攻击是基本迭代法的变体，在这种方法中，每次迭代之后，扰动被投影在指定半径的p范数球上（除了剪切对抗样本的值，使其位于允许的数据范围内）。这是Madry等人提出的用于对抗性训练的攻击。
 
     参考文献：`A. Madry, et al., "Towards deep learning models resistant to adversarial attacks," in ICLR, 2018 <https://arxiv.org/abs/1706.06083>`_。
 
@@ -206,11 +210,12 @@ mindarmour.adv_robustness.attacks
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的对抗性扰动占数据范围的比例。默认值：0.3。
     - **eps_iter** (float) - 攻击产生的单步对抗扰动占数据范围的比例。默认值：0.1。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
     - **nb_iter** (int) - 迭代次数。默认值：5。
-    - **norm_level** (Union[int, numpy.inf]) - 范数的顺序。可取值：np.inf、1或2。默认值：'inf'。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **norm_level** (Union[int, str, numpy.inf]) - 范数类型。
+      可取值：numpy.inf、1、2、'1'、'2'、'l1'、'l2'、'np.inf'、'inf'、'linf'。默认值：'numpy.inf'。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
     .. py:method:: generate(inputs, labels)
 
@@ -218,7 +223,7 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, tuple]) - 用作创建对抗样本的引用的良性输入样本。
+        - **inputs** (Union[numpy.ndarray, tuple]) - 良性输入样本，用于创建对抗样本。
         - **labels** (Union[numpy.ndarray, tuple]) - 原始/目标标签。若每个输入有多个标签，将它包装在元组中。
 
         **返回：**
@@ -235,10 +240,23 @@ mindarmour.adv_robustness.attacks
 
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的对抗性扰动占数据范围的比例。默认值：0.3。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **prob** (float) - 转换概率。默认值：0.5。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **prob** (float) - 对输入样本的转换概率。默认值：0.5。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+
+    .. py:method:: generate(inputs, labels)
+
+        基于多样性输入迭代法生成对抗样本。
+
+        **参数：**
+
+        - **inputs** (Union[numpy.ndarray, tuple]) - 良性输入样本，用于创建对抗样本。
+        - **labels** (Union[numpy.ndarray, tuple]) - 原始/目标标签。若每个输入有多个标签，将它包装在元组中。
+
+        **返回：**
+
+        - **numpy.ndarray** - 生成的对抗样本。
 
 .. py:class:: mindarmour.adv_robustness.attacks.MomentumDiverseInputIterativeMethod(network, eps=0.3, bounds=(0.0, 1.0), is_targeted=False, norm_level='l1', prob=0.5, loss_fn=None)
 
@@ -250,11 +268,12 @@ mindarmour.adv_robustness.attacks
 
     - **network** (Cell) - 目标模型。
     - **eps** (float) - 攻击产生的对抗性扰动占数据范围的比例。默认值：0.3。
-    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **bounds** (tuple) - 数据的上下界，表示数据范围。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **norm_level** (Union[int, numpy.inf]) - 范数的顺序。可取值：np.inf、1或2。默认值：'l1'。
-    - **prob** (float) - 转换概率。默认值：0.5。
-    - **loss_fn** (Loss) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
+    - **norm_level** (Union[int, str, numpy.inf]) - 范数类型。
+      可取值：numpy.inf、1、2、'1'、'2'、'l1'、'l2'、'np.inf'、'inf'、'linf'。默认值：'l1'。
+    - **prob** (float) - 对输入样本的转换概率。默认值：0.5。
+    - **loss_fn** (Union[Loss, None]) - 用于优化的损失函数。如果为None，则输入网络已配备损失函数。默认值：None。
 
 .. py:class:: mindarmour.adv_robustness.attacks.DeepFool(network, num_classes, model_type='classification', reserve_ratio=0.3, max_iters=50, overshoot=0.02, norm_level=2, bounds=None, sparse=True)
 
@@ -267,12 +286,12 @@ mindarmour.adv_robustness.attacks
     - **network** (Cell) - 目标模型。
     - **num_classes** (int) - 模型输出的标签数，应大于零。
     - **model_type** (str) - 目标模型的类型。现在支持'classification'和'detection'。默认值：'classification'。
-    - **reserve_ratio** (Union[int, float]) - 攻击后可检测到的对象百分比，特别是当model_type='detection'。保留比率应在(0, 1)的范围内。默认值：0.3。
+    - **reserve_ratio** (Union[int, float]) - 攻击后可检测到的对象百分比，仅当model_type='detection'时有效。保留比率应在(0, 1)的范围内。默认值：0.3。
     - **max_iters** (int) - 最大迭代次数，应大于零。默认值：50。
     - **overshoot** (float) - 过冲参数。默认值：0.02。
-    - **norm_level** (Union[int, str]) - 矢量范数的顺序。可取值：np.inf或2。默认值：2。
-    - **bounds** (Union[tuple, list]) - 数据范围的上下界。以(clip_min, clip_max)的形式出现。默认值：None。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **norm_level** (Union[int, str, numpy.inf]) - 矢量范数类型。可取值：numpy.inf或2。默认值：2。
+    - **bounds** (Union[tuple, list]) - 数据范围的上下界。以(数据最小值，数据最大值)的形式出现。默认值：None。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
 
     .. py:method:: generate(inputs, labels)    
 
@@ -280,8 +299,15 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, tuple]) - 输入样本。如果model_type='classification'，则输入的格式应为numpy.ndarray。输入的格式可以是(input1, input2, ...)，或者如果model_type='detection'，则只能是一个数组。    
-        - **labels** (Union[numpy.ndarray, tuple]) - 目标标签或ground-truth标签。如果model_type='classification'，标签的格式应为numpy.ndarray。如果model_type='detection'，标签的格式应为(gt_boxes, gt_labels)。
+        - **inputs** (Union[numpy.ndarray, tuple]) - 输入样本。
+
+          - 如果 `model_type` ='classification'，则输入的格式应为numpy.ndarray。输入的格式可以是(input1, input2, ...)。
+          - 如果 `model_type` ='detection'，则只能是一个数组。
+
+        - **labels** (Union[numpy.ndarray, tuple]) - 目标标签或ground-truth标签。
+
+          - 如果 `model_type` ='classification'，标签的格式应为numpy.ndarray。
+          - 如果 `model_type` ='detection'，标签的格式应为(gt_boxes, gt_labels)。
 
         **返回：**
 
@@ -289,11 +315,11 @@ mindarmour.adv_robustness.attacks
 
         **异常：**
 
-        - **NotImplementedError** - norm_level不在[2, np.inf, '2', 'inf']中。
+        - **NotImplementedError** - `norm_level` 不在[2, numpy.inf, '2', 'inf']中。
 
 .. py:class:: mindarmour.adv_robustness.attacks.CarliniWagnerL2Attack(network, num_classes, box_min=0.0, box_max=1.0, bin_search_steps=5, max_iterations=1000, confidence=0, learning_rate=5e-3, initial_const=1e-2, abort_early_check_ratio=5e-2, targeted=False, fast=True, abort_early=True, sparse=True)
 
-    使用L2范数的Carlini & Wagner攻击通过分别利用两个损失生成对抗样本：“对抗损失”可使生成的示例实际上是对抗性的，“距离损失”可以限制对抗样本的质量。
+    使用L2范数的Carlini & Wagner攻击通过分别利用两个损失生成对抗样本：“对抗损失”可使生成的示例实际上是对抗性的，“距离损失”可以控制对抗样本的质量。
 
     参考文献：`Nicholas Carlini, David Wagner: "Towards Evaluating the Robustness of Neural Networks" <https://arxiv.org/abs/1608.04644>`_。
 
@@ -303,17 +329,20 @@ mindarmour.adv_robustness.attacks
     - **num_classes** (int) - 模型输出的标签数，应大于零。
     - **box_min** (float) - 目标模型输入的下界。默认值：0。
     - **box_max** (float) - 目标模型输入的上界。默认值：1.0。
-    - **bin_search_steps** (int) - 用于查找距离和置信度之间的最优代价常数的二进制搜索的步数。默认值：5。
+    - **bin_search_steps** (int) - 用于查找距离和置信度之间的最优trade-off常数的二分查找步数。默认值：5。
     - **max_iterations** (int) - 最大迭代次数，应大于零。默认值：1000。
     - **confidence** (float) - 对抗样本输出的置信度。默认值：0。
     - **learning_rate** (float) - 攻击算法的学习率。默认值：5e-3。
-    - **initial_const** (float) - 用于平衡扰动范数和置信度差异的相对重要性的初始折衷常数。默认值：1e-2。
-    - **abort_early_check_ratio** (float) - 检查所有迭代的每个比率的损失进度。默认值：5e-2。
+    - **initial_const** (float) - 用于平衡扰动范数和置信度差异的初始trade-off常数。默认值：1e-2。
+    - **abort_early_check_ratio** (float) - 检查所有迭代中所有比率的损失进度。默认值：5e-2。
     - **targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **fast** (bool) - 如果为True，则返回第一个找到的对抗样本。
-      如果为False，则返回扰动较小的对抗样本。默认值：True。
-    - **abort_early** (bool) - 如果为True，则如果损失在一段时间内没有减少，Adam将被中止。如果为False，Adam将继续工作，直到到达最大迭代。默认值：True。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **fast** (bool) - 如果为True，则返回第一个找到的对抗样本。如果为False，则返回扰动较小的对抗样本。默认值：True。
+    - **abort_early** (bool) - 是否提前终止。
+
+      - 如果为True，则当损失在一段时间内没有减少，Adam将被中止。
+      - 如果为False，Adam将继续工作，直到到达最大迭代。默认值：True。
+
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
 
     .. py:method:: generate(inputs, labels)
 
@@ -322,7 +351,7 @@ mindarmour.adv_robustness.attacks
         **参数：**
 
         - **inputs** (numpy.ndarray) - 输入样本。
-        - **labels** (numpy.ndarray) - 输入样本或目标标签的基础真值标签。
+        - **labels** (numpy.ndarray) - 输入样本的真值标签或目标标签。
 
         **返回：**
 
@@ -343,8 +372,8 @@ mindarmour.adv_robustness.attacks
     - **theta** (float) - 一个像素的变化率（相对于输入数据范围）。默认值：1.0。
     - **max_iteration** (int) - 迭代的最大轮次。默认值：1000。
     - **max_count** (int) - 每个像素的最大更改次数。默认值：3。
-    - **increase** (bool) - 为True，则增加扰动。如果为False，则减少扰动。默认值：True。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **increase** (bool) - 如果为True，则增加扰动。如果为False，则减少扰动。默认值：True。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
 
     .. py:method:: generate(inputs, labels) 
 
@@ -361,7 +390,7 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.LBFGS(network, eps=1e-5, bounds=(0.0, 1.0), is_targeted=True, nb_iter=150, search_iters=30, loss_fn=None, sparse=False)
 
-    在L-BFGS-B攻击中，使用有限内存BFGS优化算法来最小化输入与对抗样本之间的距离。
+    L-BFGS-B攻击使用有限内存BFGS优化算法来最小化输入与对抗样本之间的距离。
 
     参考文献：`Pedro Tabacof, Eduardo Valle. "Exploring the Space of Adversarial Images" <https://arxiv.org/abs/1510.05328>`_。
 
@@ -371,10 +400,10 @@ mindarmour.adv_robustness.attacks
     - **eps** (float) - 攻击步长。默认值：1e-5。
     - **bounds** (tuple) - 数据的上下界。默认值：(0.0, 1.0)
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：True。
-    - **nb_iter** (int) - lbfgs-Optimizer的迭代次数，应大于零。默认值：150。
+    - **nb_iter** (int) - lbfgs优化器的迭代次数，应大于零。默认值：150。
     - **search_iters** (int) - 步长的变更数，应大于零。默认值：30。
     - **loss_fn** (Functions) - 替代模型的损失函数。默认值：None。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：False。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：False。
 
     .. py:method:: generate(inputs, labels)    
 
@@ -382,7 +411,7 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (numpy.ndarray) - 用作创建对抗样本的引用的良性输入样本。
+        - **inputs** (numpy.ndarray) - 良性输入样本，用于创建对抗样本。
         - **labels** (numpy.ndarray) - 原始/目标标签。
 
         **返回：**
@@ -391,7 +420,7 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.GeneticAttack(model, model_type='classification', targeted=True, reserve_ratio=0.3, sparse=True, pop_size=6, mutation_rate=0.005, per_bounds=0.15, max_steps=1000, step_size=0.20, temp=0.3, bounds=(0, 1.0), adaptive=False, c=0.1)
 
-    遗传攻击（Genetic Attack）表示基于遗传算法的黑盒攻击，属于差分进化算法。
+    遗传攻击（Genetic Attack）为基于遗传算法的黑盒攻击，属于差分进化算法。
 
     此攻击是由Moustafa Alzantot等人（2018）提出的。 
 
@@ -401,17 +430,17 @@ mindarmour.adv_robustness.attacks
 
     - **model** (BlackModel) - 目标模型。
     - **model_type** (str) - 目标模型的类型。现在支持'classification'和'detection'。默认值：'classification'。
-    - **targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。需要注意的是，model_type='detection'仅支持无目标攻击，默认值：True。
-    - **reserve_ratio** (Union[int, float]) - 攻击后可检测到的对象百分比，特别是当model_type='detection'。保留比率应在(0, 1)的范围内。默认值：0.3。
+    - **targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。 `model_type` ='detection'仅支持无目标攻击，默认值：True。
+    - **reserve_ratio** (Union[int, float]) - 攻击后可检测到的对象百分比，仅当 `model_type` ='detection'时有效。保留比率应在(0, 1)的范围内。默认值：0.3。
     - **pop_size** (int) - 粒子的数量，应大于零。默认值：6。
     - **mutation_rate** (Union[int, float]) - 突变的概率，应在（0,1）的范围内。默认值：0.005。
     - **per_bounds** (Union[int, float]) - 扰动允许的最大无穷范数距离。
     - **max_steps** (int) - 每个对抗样本的最大迭代轮次。默认值：1000。
     - **step_size** (Union[int, float]) - 攻击步长。默认值：0.2。
     - **temp** (Union[int, float]) - 用于选择的采样温度。默认值：0.3。温度越大，个体选择概率之间的差异就越大。
-    - **bounds** (Union[tuple, list, None]) - 数据的上下界。以(clip_min, clip_max)的形式出现。默认值：(0, 1.0)。
+    - **bounds** (Union[tuple, list, None]) - 数据的上下界。以(数据最小值，数据最大值)的形式出现。默认值：(0, 1.0)。
     - **adaptive** (bool) - 为True，则打开突变参数的动态缩放。如果为false，则打开静态突变参数。默认值：False。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
     - **c** (Union[int, float]) - 扰动损失的权重。默认值：0.1。
 
     .. py:method:: generate(inputs, labels)    
@@ -420,8 +449,15 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, tuple]) - 输入样本。如果model_type='classification'，则输入的格式应为numpy.ndarray。输入的格式可以是(input1, input2, ...)，或者如果model_type='detection'，则只能是一个数组。
-        - **labels** (Union[numpy.ndarray, tuple]) - 目标标签或ground-truth标签。如果model_type='classification'，标签的格式应为numpy.ndarray。如果model_type='detection'，标签的格式应为(gt_boxes, gt_labels)。
+        - **inputs** (Union[numpy.ndarray, tuple]) - 输入样本。
+
+          - 如果 `model_type` ='classification'，则输入的格式应为numpy.ndarray。输入的格式可以是(input1, input2, ...)。
+          - 如果 `model_type` ='detection'，则只能是一个数组。
+
+        - **labels** (Union[numpy.ndarray, tuple]) - 目标标签或ground-truth标签。
+
+          - 如果 `model_type` ='classification'，标签的格式应为numpy.ndarray。
+          - 如果 `model_type` ='detection'，标签的格式应为(gt_boxes, gt_labels)。
 
         **返回：**
 
@@ -439,21 +475,23 @@ mindarmour.adv_robustness.attacks
 
     - **model** (BlackModel) - 目标模型。
     - **init_num_evals** (int) - 梯度估计的初始评估数。默认值：100。
-    - **max_num_evals** (int) - 梯度估计的最大求值数。默认值：1000。
-    - **stepsize_search** (str) - 表示要如何搜索步长；可取值为'geometric_progression'、'grid_search'、'geometric_progression'。默认值：'geometric_progression'。
+    - **max_num_evals** (int) - 梯度估计的最大评估数。默认值：1000。
+    - **stepsize_search** (str) - 表示要如何搜索步长；
+
+      - 可取值为'geometric_progression'或'grid_search'。默认值：'geometric_progression'。
     - **num_iterations** (int) - 迭代次数。默认值：20。
     - **gamma** (float) - 用于设置二进制搜索阈值theta。默认值：1.0。
       对于l2攻击，二进制搜索阈值 `theta` 为 :math:`gamma / d^{3/2}` 。对于linf攻击是 :math:`gamma/d^2` 。默认值：1.0。
-    - **constraint** (str) - 要优化的范数距离。可取值为'l2'或'linf'。默认值：'l2'。
+    - **constraint** (str) - 要优化距离的范数。可取值为'l2'或'linf'。默认值：'l2'。
     - **batch_size** (int) - 批次大小。默认值：32。
     - **clip_min** (float, optional) - 最小图像组件值。默认值：0。
     - **clip_max** (float, optional) - 最大图像组件值。默认值：1。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
 
     **异常：**
 
-    - **ValueError** - stepsize_search不在['geometric_progression','grid_search']中。
-    - **ValueError** - 约束不在['l2', 'linf']中
+    - **ValueError** - `stepsize_search` 不在['geometric_progression','grid_search']中。
+    - **ValueError** - `constraint` 不在['l2', 'linf']中
 
     .. py:method:: generate(inputs, labels)    
 
@@ -480,17 +518,23 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.NES(model, scene, max_queries=10000, top_k=-1, num_class=10, batch_size=128, epsilon=0.3, samples_per_draw=128, momentum=0.9, learning_rate=1e-3, max_lr=5e-2, min_lr=5e-4, sigma=1e-3, plateau_length=20, plateau_drop=2.0, adv_thresh=0.25, zero_iters=10, starting_eps=1.0, starting_delta_eps=0.5, label_only_sigma=1e-3, conservative=2, sparse=True)
 
-    该类是自然进化策略（Natural Evolutionary Strategies，NES）攻击法的实现。NES使用自然进化策略来估计梯度，以提高查询效率。NES包括三个设置：Query-Limited设置、Partial-Information置和Label-Only设置。在query-limit设置中，攻击对目标模型的查询数量有限，但可以访问所有类的概率。在partial-info设置中，攻击仅有权访问top-k类的概率。
-    在label-only设置中，攻击只能访问按其预测概率排序的k个推断标签列表。在Partial-Information设置和Label-Only设置中，NES会进行目标攻击，因此用户需要使用set_target_images方法来设置目标类的目标图像。
+    该类是自然进化策略（Natural Evolutionary Strategies，NES）攻击法的实现。NES使用自然进化策略来估计梯度，以提高查询效率。NES包括三个设置：Query-Limited设置、Partial-Information置和Label-Only设置。
+
+    - 在'query-limit'设置中，攻击对目标模型的查询数量有限，但可以访问所有类的概率。
+    - 在'partial-info'设置中，攻击仅有权访问top-k类的概率。
+    - 在'label-only'设置中，攻击只能访问按其预测概率排序的k个推断标签列表。 
+
+    在Partial-Information设置和Label-Only设置中，NES会进行目标攻击，因此用户需要使用set_target_images方法来设置目标类的目标图像。
+
 
     参考文献：`Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. In ICML, July 2018 <https://arxiv.org/abs/1804.08598>`_。
 
     **参数：**
 
     - **model** (BlackModel) - 要攻击的目标模型。
-    - **scene** (str) - 'Label_Only'、'Partial_Info'、'Query_Limit'中的场景。
+    - **scene** (str) - 确定算法的场景，可选值为：'Label_Only'、'Partial_Info'、'Query_Limit'。
     - **max_queries** (int) - 生成对抗样本的最大查询编号。默认值：10000。
-    - **top_k** (int) - 用于Partial-Info或Label-Only设置，表示攻击者可用的（Top-k）信息数量。对于Query-Limited设置，此输入应设置为-1。默认值：-1。
+    - **top_k** (int) - 用于'Partial-Info'或'Label-Only'设置，表示攻击者可用的（Top-k）信息数量。对于Query-Limited设置，此输入应设置为-1。默认值：-1。
     - **num_class** (int) - 数据集中的类数。默认值：10。
     - **batch_size** (int) - 批次大小。默认值：128。
     - **epsilon** (float) - 攻击中允许的最大扰动。默认值：0.3。
@@ -508,7 +552,7 @@ mindarmour.adv_robustness.attacks
     - **starting_delta_eps** (float) - Label-Only设置中使用的delta epsilon。默认值：0.5。
     - **label_only_sigma** (float) - Label-Only设置中使用的Sigma。默认值：1e-3。
     - **conservative** (int) - 用于epsilon衰变的守恒，如果没有收敛，它将增加。默认值：2。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
 
     .. py:method:: generate(inputs, labels)    
 
@@ -527,13 +571,13 @@ mindarmour.adv_robustness.attacks
 
         **异常：**
 
-        - **ValueError** - 在Label-Only或Partial-Info设置中top_k小于0。
-        - **ValueError** - 在Label-Only或Partial-Info设置中target_imgs为None。
-        - **ValueError** - 场景不在['Label_Only', 'Partial_Info', 'Query_Limit']中
+        - **ValueError** - 在'Label-Only'或'Partial-Info'设置中 `top_k` 小于0。
+        - **ValueError** - 在'Label-Only'或'Partial-Info'设置中target_imgs为None。
+        - **ValueError** - `scene` 不在['Label_Only', 'Partial_Info', 'Query_Limit']中
 
     .. py:method:: set_target_images(target_images)
 
-        在Partial-Info或Label-Only设置中设置目标攻击的目标样本。
+        在'Partial-Info'或'Label-Only'设置中设置目标攻击的目标样本。
 
         **参数：**
 
@@ -552,8 +596,8 @@ mindarmour.adv_robustness.attacks
     - **max_iter** (int) - 生成对抗图像的最大迭代轮数。默认值：1000。
     - **search_iter** (int) - 二进制搜索的最大轮数。默认值：10。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **init_attack** (Attack) - 用于查找起点的攻击。默认值：None。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **init_attack** (Union[Attack, None]) - 用于查找起点的攻击。默认值：None。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
 
 
     .. py:method:: generate(inputs, labels)    
@@ -562,7 +606,7 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (numpy.ndarray) - 用作创建对抗样本的引用的良性输入样本。
+        - **inputs** (numpy.ndarray) - 良性输入样本，用于创建对抗样本。
         - **labels** (numpy.ndarray) - 对于有目标的攻击，标签是对抗性的目标标签。对于无目标攻击，标签是ground-truth标签。
 
         **返回：**
@@ -573,8 +617,8 @@ mindarmour.adv_robustness.attacks
 
 .. py:class:: mindarmour.adv_robustness.attacks.PSOAttack(model, model_type='classification', targeted=False, reserve_ratio=0.3, sparse=True, step_size=0.5, per_bounds=0.6, c1=2.0, c2=2.0, c=2.0, pop_size=6, t_max=1000, pm=0.5, bounds=None)
 
-    PSO攻击表示基于粒子群优化（Particle Swarm Optimization）算法的黑盒攻击，属于差分进化算法。
-    此攻击是由Rayan Mosli等人（2019）提出的。 
+    PSO攻击表示基于粒子群优化（Particle Swarm Optimization）算法的黑盒攻击，属于进化算法。
+    此攻击由Rayan Mosli等人（2019）提出。 
 
     参考文献：`Rayan Mosli, Matthew Wright, Bo Yuan, Yin Pan, "They Might NOT Be Giants: Crafting Black-Box Adversarial Examples with Fewer Queries Using Particle Swarm Optimization", arxiv: 1909.07490, 2019. <https://arxiv.org/abs/1909.07490>`_。
 
@@ -589,11 +633,11 @@ mindarmour.adv_robustness.attacks
     - **pop_size** (int) - 粒子的数量，应大于零。默认值：6。
     - **t_max** (int) - 每个对抗样本的最大迭代轮数，应大于零。默认值：1000。
     - **pm** (Union[int, float]) - 突变的概率，应在（0,1）的范围内。默认值：0.5。
-    - **bounds** (Union[list, tuple, None]) - 数据的上下界。以(clip_min, clip_max)的形式出现。默认值：None。
-    - **targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。需要注意的是，model_type='detection'仅支持无目标攻击，默认值：False。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **bounds** (Union[list, tuple, None]) - 数据的上下界。以(数据最小值，数据最大值)的形式出现。默认值：None。
+    - **targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。 `model_type` ='detection'仅支持无目标攻击，默认值：False。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
     - **model_type** (str) - 目标模型的类型。现在支持'classification'和'detection'。默认值：'classification'。
-    - **reserve_ratio** (Union[int, float]) - 攻击后可检测到的对象百分比，特别是当model_type='detection'。保留比率应在(0, 1)的范围内。默认值：0.3。
+    - **reserve_ratio** (Union[int, float]) - 攻击后可检测到的对象百分比，用于 `model_type` ='detection'模式。保留比率应在(0, 1)的范围内。默认值：0.3。
 
     .. py:method:: generate(inputs, labels)
 
@@ -601,8 +645,15 @@ mindarmour.adv_robustness.attacks
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, tuple]) - 输入样本。如果model_type='classification'，则输入的格式应为numpy.ndarray。输入的格式可以是(input1, input2, ...)，或者如果model_type='detection'，则只能是一个数组。
-        - **labels** (Union[numpy.ndarray, tuple]) - 目标标签或ground-truth标签。如果model_type='classification'，标签的格式应为numpy.ndarray。如果model_type='detection'，标签的格式应为(gt_boxes, gt_labels)。
+        - **inputs** (Union[numpy.ndarray, tuple]) - 输入样本。
+
+          - 如果 `model_type` ='classification'，则输入的格式应为numpy.ndarray。输入的格式可以是(input1, input2, ...)。
+          - 如果 `model_type` ='detection'，则只能是一个数组。
+
+        - **labels** (Union[numpy.ndarray, tuple]) - 目标标签或ground-truth标签。
+
+          - 如果 `model_type` ='classification'，标签的格式应为numpy.ndarray。
+          - 如果 `model_type` ='detection'，标签的格式应为(gt_boxes, gt_labels)。
 
         **返回：**
 
@@ -617,10 +668,10 @@ mindarmour.adv_robustness.attacks
     **参数：**
 
     - **model** (BlackModel) - 目标模型。
-    - **bounds** (tuple) - 数据的上下界。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
+    - **bounds** (tuple) - 数据的上下界。以(数据最小值，数据最大值)的形式出现。默认值：(0.0, 1.0)。
     - **max_iter** (int) - 生成对抗样本的最大迭代。默认值：100。
     - **is_targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：True。
+    - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为one-hot编码。默认值：True。
 
     .. py:method:: generate(inputs, labels)
 
diff --git a/docs/api/api_python/mindarmour.adv_robustness.defenses.rst b/docs/api/api_python/mindarmour.adv_robustness.defenses.rst
index c78a0b8..03f4a41 100644
--- a/docs/api/api_python/mindarmour.adv_robustness.defenses.rst
+++ b/docs/api/api_python/mindarmour.adv_robustness.defenses.rst
@@ -10,7 +10,7 @@ mindarmour.adv_robustness.defenses
     **参数：**
 
     - **network** (Cell) - 要防御的MindSpore网络。
-    - **loss_fn** (Functions) - 损失函数。默认值：None。
+    - **loss_fn** (Union[Loss, None]) - 损失函数。默认值：None。
     - **optimizer** (Cell) - 用于训练网络的优化器。默认值：None。
 
     .. py:method:: defense(inputs, labels)
@@ -33,15 +33,15 @@ mindarmour.adv_robustness.defenses
     **参数：**
 
     - **network** (Cell) - 要防御的MindSpore网络。
-    - **attacks** (list[Attack]) - 攻击方法列表。
-    - **loss_fn** (Functions) - 损失函数。默认值：None。
+    - **attacks** (list[Attack]) - 攻击方法序列。
+    - **loss_fn** (Union[Loss, None]) - 损失函数。默认值：None。
     - **optimizer** (Cell) - 用于训练网络的优化器。默认值：None。
     - **bounds** (tuple) - 数据的上下界。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
-    - **replace_ratio** (float) - 用对抗性替换原始样本的比率，必须在0到1之间。默认值：0.5。
+    - **replace_ratio** (float) - 用对抗样本替换原始样本的比率，必须在0到1之间。默认值：0.5。
 
     **异常：**
 
-    - **ValueError** - 替换比率不在0和1之间。
+    - **ValueError** - `replace_ratio` 不在0和1之间。
 
     .. py:method:: defense(inputs, labels)
 
@@ -60,12 +60,12 @@ mindarmour.adv_robustness.defenses
 
     基于FGSM的对抗性训练。
 
-    参考文献：`A. Kurakin, et al., "Adversarial machine learning at scale," in ICLR, 2017. <https://arxiv.org/abs/1611.01236>`_ 。
+    参考文献：`A. Kurakin, et al., "Adversarial machine learning at scale," in ICLR, 2017 <https://arxiv.org/abs/1611.01236>`_。
 
     **参数：**
 
     - **network** (Cell) - 要防御的MindSpore网络。
-    - **loss_fn** (Functions) - 损失函数。默认值：None。
+    - **loss_fn** (Union[Loss, None]) - 损失函数。默认值：None。
     - **optimizer** (Cell)：用于训练网络的优化器。默认值：None。
     - **bounds** (tuple) - 数据的上下界。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
     - **replace_ratio** (float) - 用对抗样本替换原始样本的比率。默认值：0.5。
@@ -75,12 +75,12 @@ mindarmour.adv_robustness.defenses
 
     基于PGD的对抗性训练。
 
-    参考文献：`A. Madry, et al., "Towards deep learning models resistant to adversarial attacks," in ICLR, 2018. <https://arxiv.org/abs/1611.01236>`_ 。
+    参考文献：`A. Madry, et al., "Towards deep learning models resistant to adversarial attacks," in ICLR, 2018 <https://arxiv.org/abs/1611.01236>`_。
 
     **参数：**
 
     - **network** (Cell) - 要防御的MindSpore网络。
-    - **loss_fn** (Functions) - 损失函数。默认值：None。
+    - **loss_fn** (Union[Loss, None]) - 损失函数。默认值：None。
     - **optimizer** (Cell) - 用于训练网络的优化器。默认值：None。
     - **bounds** (tuple) - 输入数据的上下界。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
     - **replace_ratio** (float) - 用对抗样本替换原始样本的比率。默认值：0.5。
@@ -96,12 +96,12 @@ mindarmour.adv_robustness.defenses
     **参数：**
 
     - **network** (Cell) - 要防御的MindSpore网络。
-    - **attacks** (list[Attack]) - 攻击方法列表。
-    - **loss_fn** (Functions) - 损失函数。默认值：None。
+    - **attacks** (list[Attack]) - 攻击方法序列。
+    - **loss_fn** (Union[Loss, None]) - 损失函数。默认值：None。
     - **optimizer** (Cell) - 用于训练网络的优化器。默认值：None。
     - **bounds** (tuple) - 数据的上下界。以(clip_min, clip_max)的形式出现。默认值：(0.0, 1.0)。
-    - **replace_ratio** (float) - 用对抗性替换原始样本的比率，必须在0到1之间。默认值：0.5。
+    - **replace_ratio** (float) - 用对抗样本替换原始样本的比率，必须在0到1之间。默认值：0.5。
 
     **异常：**
 
-    - **ValueError** - `bounds` 不在0和1之间。
+    - **ValueError** - `replace_ratio` 不在0和1之间。
diff --git a/docs/api/api_python/mindarmour.adv_robustness.detectors.rst b/docs/api/api_python/mindarmour.adv_robustness.detectors.rst
index d778ec8..d1771bd 100644
--- a/docs/api/api_python/mindarmour.adv_robustness.detectors.rst
+++ b/docs/api/api_python/mindarmour.adv_robustness.detectors.rst
@@ -1,7 +1,7 @@
 mindarmour.adv_robustness.detectors
 ===================================
 
-此模块包括用于区分对抗样本和良性样本的检测器方法。
+此模块是用于区分对抗样本和良性样本的检测器方法。
 
 .. py:class:: mindarmour.adv_robustness.detectors.ErrorBasedDetector(auto_encoder, false_positive_rate=0.01, bounds=(0.0, 1.0))
 
@@ -11,7 +11,7 @@ mindarmour.adv_robustness.detectors
 
     **参数：**
 
-    - **auto_encoder** (Model) - 一个（训练过的）自动编码器，通过减少编码表示输入。
+    - **auto_encoder** (Model) - 一个（训练过的）自动编码器，对输入图片进行重构。
     - **false_positive_rate** (float) - 检测器的误报率。默认值：0.01。
     - **bounds** (tuple) - (clip_min, clip_max)。默认值：(0.0, 1.0)。
 
@@ -54,7 +54,7 @@ mindarmour.adv_robustness.detectors
 
     .. py:method:: set_threshold(threshold)    
 
-        设置参数阈值。
+        设置阈值。
 
         **参数：**
 
@@ -106,6 +106,8 @@ mindarmour.adv_robustness.detectors
 
 .. py:class:: mindarmour.adv_robustness.detectors.RegionBasedDetector(model, number_points=10, initial_radius=0.0, max_radius=1.0, search_step=0.01, degrade_limit=0.0, sparse=False)
 
+    基于区域的检测器利用对抗样本靠近分类边界的事实，并通过集成给定示例周围的信息，以检测输入是否为对抗样本。
+
     参考文献： `Mitigating evasion attacks to deep neural networks via region-based classification <https://arxiv.org/abs/1709.05583>`_。
 
     **参数：**
@@ -114,7 +116,7 @@ mindarmour.adv_robustness.detectors
     - **number_points** (int) - 从原始样本的超立方体生成的样本数。默认值：10。
     - **initial_radius** (float) - 超立方体的初始半径。默认值：0.0。
     - **max_radius** (float) - 超立方体的最大半径。默认值：1.0。
-    - **search_step** (float) - 搜索半径期间增量。默认值：0.01。
+    - **search_step** (float) - 半径搜索增量。默认值：0.01。
     - **degrade_limit** (float) - 分类精度的可接受下降。默认值：0.0。
     - **sparse** (bool) - 如果为True，则输入标签为稀疏编码。如果为False，则输入标签为onehot编码。默认值：False。
 
@@ -173,7 +175,7 @@ mindarmour.adv_robustness.detectors
 
         **返回：**
 
-        - **numpy.ndarray** - 超立方体对应于每个样本。
+        - **numpy.ndarray** - 每个样本对应的超立方体。
 
 .. py:class:: mindarmour.adv_robustness.detectors.SpatialSmoothing(model, ksize=3, is_local_smooth=True, metric='l1', false_positive_ratio=0.05)
 
@@ -198,7 +200,7 @@ mindarmour.adv_robustness.detectors
 
         **返回：**
 
-        - **list[int]** - 样本是否具有对抗性。如果res[i]=1，则索引为i的输入样本是对抗性的。
+        - **list[int]** - 样本是否具有对抗性。如果res[i]=1，则索引为i的输入样本是对抗样本。
 
     .. py:method:: detect_diff(inputs)    
 
@@ -227,7 +229,7 @@ mindarmour.adv_robustness.detectors
 
     .. py:method:: set_threshold(threshold)    
 
-        设置参数阈值。
+        设置阈值。
 
         **参数：**
 
@@ -235,6 +237,8 @@ mindarmour.adv_robustness.detectors
 
 .. py:class:: mindarmour.adv_robustness.detectors.EnsembleDetector(detectors, policy='vote')
 
+    集合检测器，通过检测器列表从输入样本中检测对抗样本。
+
     **参数：**
 
     - **detectors** (Union[tuple, list]) - 检测器方法列表。
@@ -250,7 +254,7 @@ mindarmour.adv_robustness.detectors
 
         **返回：**
 
-        - **list[int]** - 样本是否具有对抗性。如果res[i]=1，则索引为i的输入样本是对抗性的。
+        - **list[int]** - 样本是否具有对抗性。如果res[i]=1，则索引为i的输入样本是对抗样本。
 
         **异常：**
 
@@ -262,7 +266,7 @@ mindarmour.adv_robustness.detectors
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, list, tuple]) - 数据被用作创建对抗样本的引用。
+        - **inputs** (Union[numpy.ndarray, list, tuple]) - 用于创建对抗样本。
 
         **异常：**
 
@@ -288,7 +292,7 @@ mindarmour.adv_robustness.detectors
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, list, tuple]) - 数据被用作创建对抗样本的引用。
+        - **inputs** (Union[numpy.ndarray, list, tuple]) - 用于创建对抗样本。
 
         **异常：**
 
@@ -305,8 +309,12 @@ mindarmour.adv_robustness.detectors
     - **trans_model** (Model) - 一个MindSpore模型，将输入数据编码为低维向量。
     - **max_k_neighbor** (int) - 最近邻的最大数量。默认值：1000。
     - **chunk_size** (int) - 缓冲区大小。默认值：1000。
-    - **max_buffer_size** (int) - 最大缓冲区大小。默认值：10000。默认值：False。
-    - **tuning** (bool) - 计算k个最近邻的平均距离，如果'tuning'为true，k=K。如果为False，k=1,...,K。默认值：False。
+    - **max_buffer_size** (int) - 最大缓冲区大小。默认值：10000。
+    - **tuning** (bool) - 计算k个最近邻的平均距离。
+
+      - 如果'tuning'为true，k= `max_k_neighbor` 。
+      - 如果为False，k=1,..., `max_k_neighbor` 。默认值：False。
+
     - **fpr** (float) - 合法查询序列上的误报率。默认值：0.001
 
     .. py:method:: clear_buffer()    
@@ -319,11 +327,11 @@ mindarmour.adv_robustness.detectors
 
         **参数：**
 
-        - **inputs** (numpy.ndarray) - 查询顺序。
+        - **inputs** (numpy.ndarray) - 查询序列。
 
         **异常：**
 
-        - **ValueError** - 阈值或num_of_neighbors的参数不可用。
+        - **ValueError** - 阈值或set_threshold方法中 `num_of_neighbors` 参数不可用。
 
     .. py:method:: detect_diff(inputs)    
 
@@ -331,11 +339,11 @@ mindarmour.adv_robustness.detectors
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, list, tuple]) - 数据被用作创建对抗样本的引用。
+        - **inputs** (Union[numpy.ndarray, list, tuple]) - 用于创建对抗样本。
 
         **异常：**
 
-        - **NotImplementedError** - 此函数在类 `SimilarityDetector` 中不可用。
+        - **NotImplementedError** - 此函数在 `SimilarityDetector` 类（class）中不可用。
 
     .. py:method:: fit(inputs, labels=None)    
 
@@ -351,11 +359,11 @@ mindarmour.adv_robustness.detectors
 
         - **list[int]** - 最近邻的数量。
 
-        - **list[float]** - 不同K的计算阈值。
+        - **list[float]** - 不同k的阈值。
 
         **异常：**
 
-        - **ValueError** - 训练数据个数小于max_k_neighbor!
+        - **ValueError** - 训练数据个数小于 `max_k_neighbor`。
 
     .. py:method:: get_detected_queries()    
 
@@ -373,7 +381,7 @@ mindarmour.adv_robustness.detectors
 
         - **list[int]** - 相邻检测之间的查询数。
 
-    .. py:method:: set_threshold(threshold, num_of_neighbors)    
+    .. py:method:: set_threshold(num_of_neighbors, threshold)    
 
         设置参数num_of_neighbors和threshold。
 
@@ -388,8 +396,8 @@ mindarmour.adv_robustness.detectors
 
         **参数：**
 
-        - **inputs** (Union[numpy.ndarray, list, tuple]) - 数据被用作创建对抗样本的引用。
+        - **inputs** (Union[numpy.ndarray, list, tuple]) - 用于创建对抗样本。
 
         **异常：**
 
-        - **NotImplementedError** - 此函数在类 `SimilarityDetector` 中不可用。
+        - **NotImplementedError** - 此函数在 `SimilarityDetector` 类（class）中不可用。
diff --git a/docs/api/api_python/mindarmour.adv_robustness.evaluations.rst b/docs/api/api_python/mindarmour.adv_robustness.evaluations.rst
index 78ccf49..9bacbe8 100644
--- a/docs/api/api_python/mindarmour.adv_robustness.evaluations.rst
+++ b/docs/api/api_python/mindarmour.adv_robustness.evaluations.rst
@@ -12,13 +12,13 @@ mindarmour.adv_robustness.evaluations
     - **inputs** (numpy.ndarray) - 原始样本。
     - **labels** (numpy.ndarray) - 原始样本的one-hot格式标签。
     - **adv_inputs** (numpy.ndarray) - 从原始样本生成的对抗样本。
-    - **adv_preds** (numpy.ndarray) - 对抗样本的所有输出类的概率。
+    - **adv_preds** (numpy.ndarray) - 对对抗样本的对所有标签的预测概率。
     - **targeted** (bool) - 如果为True，则为目标攻击。如果为False，则为无目标攻击。默认值：False。
-    - **target_label** (numpy.ndarray) - 对抗样本的目标类，是大小为adv_inputs.shape[0]的一维。默认值：None。
+    - **target_label** (numpy.ndarray) - 对抗样本的目标标签，是大小为adv_inputs.shape[0]的一维。默认值：None。
 
     **异常：**
 
-    - **ValueError** - 如果targeted为True时，target_label为None。
+    - **ValueError** - 如果 `targeted` 为True时， `target_label` 为None。
 
     .. py:method:: avg_conf_adv_class()
 
@@ -42,9 +42,10 @@ mindarmour.adv_robustness.evaluations
 
         **返回：**
 
-        - **float** - 返回所有成功对抗样本的平均'l0'、'l2'或'linf'距离，返回值包括以下情况。
-          如果返回值 :math:`>=` 0，则为平均lp距离。值越低，攻击就越成功。
-          如果返回值为-1，则没有成功的对抗样本。
+        - **float** - 返回所有成功对抗样本的平均'l0'、'l2'或'linf'距离，返回值包括以下情况：
+          
+          - 如果返回值 :math:`>=` 0，则为平均lp距离。值越低，攻击就越成功。
+          - 如果返回值为-1，则没有成功的对抗样本。
 
     .. py:method:: avg_ssim()
 
@@ -53,8 +54,9 @@ mindarmour.adv_robustness.evaluations
         **返回：**
 
         - **float** - 平均结构相似性。
-          如果返回值在（0,1）之间，则值越高，攻击越成功。
-          如果返回值为-1，则没有成功的对抗样本。
+
+          - 如果返回值在（0,1）之间，则值越高，攻击越成功。
+          - 如果返回值为-1，则没有成功的对抗样本。
 
     .. py:method:: mis_classification_rate()
 
@@ -80,14 +82,14 @@ mindarmour.adv_robustness.evaluations
 
     **参数：**
 
-    - **raw_preds** (numpy.ndarray) - 预测原始模型上某些样本的结果。
-    - **def_preds** (numpy.ndarray) - 预测防御模型上某些样本的结果。
-    - **raw_query_counts** (numpy.ndarray) - 在原始模型上生成对抗样本的查询数，原始模型是大小为raw_preds.shape[0]的一维。对于良性样本，查询计数必须设置为0。
-    - **def_query_counts** (numpy.ndarray) - 在防御模型上生成对抗样本的查询数，原始模型是大小为raw_preds.shape[0]的一维。对于良性样本，查询计数必须设置为0。
-    - **raw_query_time** (numpy.ndarray) - 在原始模型上生成对抗样本的总持续时间，该样本是大小为raw_preds.shape[0]的一维。
-    - **def_query_time** (numpy.ndarray) - 在防御模型上生成对抗样本的总持续时间，该样本是大小为raw_preds.shape[0]的一维。
-    - **def_detection_counts** (numpy.ndarray) - 每次对抗样本生成期间检测到的查询总数，大小为raw_preds.shape[0]的一维。对于良性样本，如果查询被识别为可疑，则将def_detection_counts设置为1，否则将其设置为0。
-    - **true_labels** (numpy.ndarray) - 大小为raw_preds.shape[0]的一维真标签。
+    - **raw_preds** (numpy.ndarray) - 原始模型上特定样本的预测结果。
+    - **def_preds** (numpy.ndarray) - 原始防御模型上特定样本的预测结果。
+    - **raw_query_counts** (numpy.ndarray) - 在原始模型上生成对抗样本的查询数，原始模型是大小是与raw_preds.shape[0]的第一纬度相同。对于良性样本，查询计数必须设置为0。
+    - **def_query_counts** (numpy.ndarray) - 在防御模型上生成对抗样本的查询数，原始模型是大小是与raw_preds.shape[0]的第一纬度相同。对于良性样本，查询计数必须设置为0。
+    - **raw_query_time** (numpy.ndarray) - 在原始模型上生成对抗样本的总持续时间，该样本是大小是与raw_preds.shape[0]的第一纬度。
+    - **def_query_time** (numpy.ndarray) - 在防御模型上生成对抗样本的总持续时间，该样本是大小是与raw_preds.shape[0]的第一纬度。
+    - **def_detection_counts** (numpy.ndarray) - 每次对抗样本生成期间检测到的查询总数，大小是与raw_preds.shape[0]的第一纬度。对于良性样本，如果查询被识别为可疑，则将def_detection_counts设置为1，否则将其设置为0。
+    - **true_labels** (numpy.ndarray) - 大小是与raw_preds.shape[0]的第一纬度真标签。
     - **max_queries** (int) - 攻击预算，最大查询数。
 
     .. py:method:: asv()
@@ -186,7 +188,7 @@ mindarmour.adv_robustness.evaluations
 
     **异常：**
 
-    - **ValueError** - scale值不在['hide', 'norm', 'sparse', 'dense']中。
+    - **ValueError** - `scale` 值不在['hide', 'norm', 'sparse', 'dense']中。
 
     .. py:method:: show()
 
diff --git a/docs/api/api_python/mindarmour.reliability.rst b/docs/api/api_python/mindarmour.reliability.rst
index 4a22a7e..ad9869b 100644
--- a/docs/api/api_python/mindarmour.reliability.rst
+++ b/docs/api/api_python/mindarmour.reliability.rst
@@ -12,13 +12,13 @@ MindArmour的可靠性方法。
     **参数：**
 
     - **model** (Model) - 需要评估模型。
-    - **fi_type** (list) - 故障注入的类型，包括bitflips_random（随机翻转）、bitflips_designated（翻转关键位）、random、zeros、nan、inf、anti_activation precision_loss等。
-    - **fi_mode** (list) - 故障注入的模式。仅在单层或所有层上注入故障。
+    - **fi_type** (list) - 故障注入的类型，包括'bitflips_random'（随机翻转）、'bitflips_designated'（翻转关键位）、'random'、'zeros'、'nan'、'inf'、'anti_activation'、'precision_loss'等。
+    - **fi_mode** (list) - 故障注入的模式。可选值：'single_layer'，'all_layer'。
     - **fi_size** (list) - 故障注入的次数，表示需要注入多少值。
 
     .. py:method:: kick_off(ds_data, ds_label, iter_times=100)
 
-        故障注入后启动并返回最终结果。
+        启动故障注入并返回最终结果。
 
         **参数：**
 
@@ -41,21 +41,22 @@ MindArmour的可靠性方法。
 .. py:class:: mindarmour.reliability.ConceptDriftCheckTimeSeries(window_size=100, rolling_window=10, step=10, threshold_index=1.5, need_label=False)
 
     概念漂移检查时间序列（ConceptDriftCheckTimeSeries）用于样本序列分布变化检测。
+
     有关详细信息，请查看 `实现时序数据概念漂移检测应用
     <https://mindspore.cn/mindarmour/docs/zh-CN/master/concept_drift_time_series.html>`_。
 
     **参数：**
 
-    - **window_size** (int) - 概念窗口的大小，不小于10。如果给定输入数据，window_size在[10, 1/3*len(input_data)]中。
-      如果数据是周期性的，通常window_size等于2-5个周期。例如，对于月/周数据，30/7天的数据量是一个周期。默认值：100。
-    - **rolling_window** (int) - 平滑窗口大小，在[1, window_size]中。默认值：10。
-    - **step** (int) - 滑动窗口的跳跃长度，在[1, window_size]中。默认值：10。
+    - **window_size** (int) - 概念窗口的大小，不小于10。如果给定输入数据， `window_size` 在[10, 1/3*len( `data` )]中。
+      如果数据是周期性的，通常 `window_size` 等于2-5个周期。例如，对于月/周数据，30/7天的数据量是一个周期。默认值：100。
+    - **rolling_window** (int) - 平滑窗口大小，在[1, `window_size` ]中。默认值：10。
+    - **step** (int) - 滑动窗口的跳跃长度，在[1, `window_size` ]中。默认值：10。
     - **threshold_index** (float) - 阈值索引，:math:`(-\infty, +\infty)` 。默认值：1.5。
-    - **need_label** (bool) - False或True。如果need_label=True，则需要概念漂移标签。默认值：False。
+    - **need_label** (bool) - False或True。如果 `need_label` =True，则需要概念漂移标签。默认值：False。
 
     .. py:method:: concept_check(data)
 
-        在数据系列中查找概念漂移位置。
+        在数据序列中查找概念漂移位置。
 
         **参数：**
 
@@ -113,7 +114,7 @@ MindArmour的可靠性方法。
 
     - **model** (Model) - 训练模型。
     - **ds_train** (numpy.ndarray) - 训练数据集。
-    - **n_cluster** (int) - 聚类编号。取值属于[2,100]。
+    - **n_cluster** (int) - 聚类数量。取值属于[2,100]。
       通常，n_cluster等于训练数据集的类号。如果OOD检测器在测试数据集中性能较差，我们可以适当增加n_cluster的值。
     - **layer** (str) - 特征层的名称。layer (str)由'name[:Tensor]'表示，其中'name'由用户在训练模型时给出。
       请查看有关如何在'README.md'中命名模型层的更多详细信息。
@@ -131,7 +132,7 @@ MindArmour的可靠性方法。
 
     .. py:method:: ood_predict(threshold, ds_test)
 
-        分布外（out-of-distribution，OOD）检测。此函数的目的是检测被视为 `ds_test` 的图像是否为OOD样本。如果一张图像的预测分数大于 `threshold` ，则该图像为分布外。
+        分布外（out-of-distribution，OOD）检测。此函数的目的是检测 `ds_test` 中的图像是否为OOD样本。如果一张图像的预测分数大于 `threshold` ，则该图像为分布外。
 
         **参数：**
 
diff --git a/docs/api/api_python/mindarmour.rst b/docs/api/api_python/mindarmour.rst
index 0967579..6204dc8 100644
--- a/docs/api/api_python/mindarmour.rst
+++ b/docs/api/api_python/mindarmour.rst
@@ -129,7 +129,7 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
     .. py:method:: batch_defense(inputs, labels, batch_size=32, epochs=5)
 
-        带有批量样本的防御模型。
+        对输入进行批量防御操作。
 
         **参数：**
 
@@ -140,15 +140,15 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
         **返回：**
 
-        - **numpy.ndarray** - 批处理防御操作的损失。
+        - **numpy.ndarray** - `batch_defense` 操作的损失。
 
         **异常：**
 
-        - **ValueError** - batch_size为0。
+        - **ValueError** - `batch_size` 为0。
 
     .. py:method:: defense(inputs, labels)
 
-        带样本的防御模型。
+        对输入进行防御操作。
 
         **参数：**
 
@@ -221,21 +221,22 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
     DPModel用于构建差分隐私训练的模型。
 
-    这个类就是重载Mindpore.train.model.Model。
+    此类重载 :class:`mindspore.Model`。
 
     详情请查看： `应用差分隐私机制保护用户隐私 <https://mindspore.cn/mindarmour/docs/zh-CN/master/protect_user_privacy_with_differential_privacy.html#%E5%B7%AE%E5%88%86%E9%9A%90%E7%A7%81>`_。
 
     **参数：**
 
     - **micro_batches** (int) - 从原始批次拆分的小批次数。默认值：2。
-    - **norm_bound** (float) - 用于剪裁绑定，如果设置为1，将返回原始数据。默认值：1.0。
-    - **noise_mech** (float) - 对象可以生成不同类型的噪音。默认值：None。
+    - **norm_bound** (float) - 用于剪裁的约束，如果设置为1，将返回原始数据。默认值：1.0。
+    - **noise_mech** (Mechanisms) - 对象可以生成不同类型的噪音。默认值：None。
     - **clip_mech** (Mechanisms) - 该对象用于更新自适应剪裁。默认值：None。
+    - **optimizer** (Cell) - 差分隐私训练用到的优化器，可以是MindSpore提供的原装优化器或者'DPOptimizerClassFatory'构造的差分隐私优化器。默认值：None。
 
     **异常：**
 
-    - **ValueError** - DPOptimizer和noise_mech都为None或非None。
-    - **ValueError** - noise_mech或DPOtimizer的mech方法是自适应的，而clip_mech不是None。
+    - **ValueError** - `optimizer` 和 `noise_mech` 都为None或都为非None。
+    - **ValueError** - `noise_mech` 或 `optimizer` 的'mech'方法是自适应的，而clip_mech不是None。
 
 .. py:class:: mindarmour.MembershipInference(model, n_jobs=-1)
 
@@ -315,8 +316,8 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
     **异常：**
 
     - **TypeError** - 网络类型不是Cell。
-    - **ValueError** - input_shape的值都不是正int。
-    - **ValueError** - loss_weights的值都不是正值。
+    - **ValueError** - `input_shape` 的值都不是正int。
+    - **ValueError** - `loss_weights` 的值都不是正值。
 
     .. py:method:: evaluate(original_images, inversion_images, labels=None, new_network=None)
 
@@ -326,8 +327,8 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
         - **original_images** (numpy.ndarray) - 原始图像，其形状应为(img_num, channels, img_width, img_height)。
         - **inversion_images** (numpy.ndarray) - 还原图像，其形状应为(img_num, channels, img_width, img_height)。
-        - **labels** (numpy.ndarray) - 原始图像的ground truth标签。默认值：None。
-        - **new_network** (Cell) - 其结构包含self._network所有部分的网络。_network，但加载了不同的模型文件。默认值：None。
+        - **labels** (numpy.ndarray) - 原始图像的ground-truth标签。默认值：None。
+        - **new_network** (Cell) - 其结构包含self._network所有部分的网络，但加载了不同的模型文件。默认值：None。
 
         **返回：**
 
@@ -342,7 +343,7 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
         **参数：**
 
         - **target_features** (numpy.ndarray) - 原始图像的深度表示。 `target_features` 的第一个维度应该是img_num。
-          需要注意的是，如果img_num等于1，则target_features的形状应该是(1, dim2, dim3, ...)。
+          需要注意的是，如果img_num等于1，则 `target_features` 的形状应该是(1, dim2, dim3, ...)。
         - **iters** (int) - 逆向攻击的迭代次数，应为正整数。默认值：100。
 
         **返回：**
@@ -351,8 +352,8 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
         **异常：**
 
-        - **TypeError** - target_features的类型不是numpy.ndarray。
-        - **ValueError** - iters的值都不是正int.Z
+        - **TypeError** - `target_features` 的类型不是numpy.ndarray。
+        - **ValueError** - `iters` 的值都不是正int.Z
 
 .. py:class:: mindarmour.ConceptDriftCheckTimeSeries(window_size=100, rolling_window=10, step=10, threshold_index=1.5, need_label=False)
 
@@ -370,7 +371,7 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
     .. py:method:: concept_check(data)
 
-        在数据系列中查找概念漂移位置。
+        在数据序列中查找概念漂移位置。
 
         **参数：**
 
diff --git a/docs/api/api_python/mindarmour.utils.rst b/docs/api/api_python/mindarmour.utils.rst
index 188c589..a93681d 100644
--- a/docs/api/api_python/mindarmour.utils.rst
+++ b/docs/api/api_python/mindarmour.utils.rst
@@ -119,6 +119,7 @@ MindArmour的工具方法。
         **参数：**
 
         - **data** (Tensor) - 数据由输入和权重组成。
+
           - inputs: 网络的输入。
           - weight: 每个梯度的权重，'weight'与'labels'的shape相同。
 
diff --git a/mindarmour/adv_robustness/attacks/black/hop_skip_jump_attack.py b/mindarmour/adv_robustness/attacks/black/hop_skip_jump_attack.py
index 863a69b..9a86f1d 100644
--- a/mindarmour/adv_robustness/attacks/black/hop_skip_jump_attack.py
+++ b/mindarmour/adv_robustness/attacks/black/hop_skip_jump_attack.py
@@ -52,7 +52,7 @@ class HopSkipJumpAttack(Attack):
         max_num_evals (int): The maximum number of evaluations for gradient
             estimation. Default: 1000.
         stepsize_search (str): Indicating how to search for stepsize; Possible
-            values are 'geometric_progression', 'grid_search', 'geometric_progression'.
+            values are 'geometric_progression', 'grid_search'.
             Default: 'geometric_progression'.
         num_iterations (int): The number of iterations. Default: 20.
         gamma (float): Used to set binary search threshold theta. Default: 1.0.
diff --git a/mindarmour/adv_robustness/attacks/carlini_wagner.py b/mindarmour/adv_robustness/attacks/carlini_wagner.py
index 224b7d8..b0d8a02 100644
--- a/mindarmour/adv_robustness/attacks/carlini_wagner.py
+++ b/mindarmour/adv_robustness/attacks/carlini_wagner.py
@@ -60,7 +60,7 @@ class CarliniWagnerL2Attack(Attack):
     """
     The Carlini & Wagner attack using L2 norm generates the adversarial examples
     by utilizing two separate losses: an adversarial loss to make the generated example
-    actually adversarial, and a distance loss to constraint the quality of the adversarial example.
+    actually adversarial, and a distance loss to control the quality of the adversarial example.
 
     References: `Nicholas Carlini, David Wagner: "Towards Evaluating
     the Robustness of Neural Networks" <https://arxiv.org/abs/1608.04644>`_
diff --git a/mindarmour/adv_robustness/detectors/mag_net.py b/mindarmour/adv_robustness/detectors/mag_net.py
index b4eda97..d06b18f 100644
--- a/mindarmour/adv_robustness/detectors/mag_net.py
+++ b/mindarmour/adv_robustness/detectors/mag_net.py
@@ -41,10 +41,8 @@ class ErrorBasedDetector(Detector):
     <https://arxiv.org/abs/1705.09064>`_
 
     Args:
-        auto_encoder (Model): An (trained) auto encoder which
-            represents the input by reduced encoding.
-        false_positive_rate (float): Detector's false positive rate.
-            Default: 0.01.
+        auto_encoder (Model): An (trained) auto encoder which reconstructs the input image.
+        false_positive_rate (float): Detector's false positive rate. Default: 0.01.
         bounds (tuple): (clip_min, clip_max). Default: (0.0, 1.0).
 
     Examples: