!379 fix api problems

Merge pull request !379 from jxlang910/master

docs/api/api_python/mindarmour.privacy.diff_privacy.rst

@@ -5,18 +5,18 @@ mindarmour.privacy.diff_privacy
 
 .. py:class:: mindarmour.privacy.diff_privacy.NoiseGaussianRandom(norm_bound=1.0, initial_noise_multiplier=1.0, seed=0, decay_policy=None)
 
-    基于高斯机制产生噪声，方法是 :math:`mean=0` 以及 :math:`standard\_deviation = norm\_bound * initial\_noise\_multiplier` 。
+    基于 :math:`mean=0` 以及 :math:`standard\_deviation = norm\_bound * initial\_noise\_multiplier` 的高斯分布产生噪声。
 
     **参数：**
 
     - **norm_bound** (float)- 梯度的l2范数的裁剪范围。默认值：1.0。
-    - **initial_noise_multiplier** (float)- 高斯噪声标准偏差除以norm_bound的比率，将用于计算隐私预算。默认值：1.0。
+    - **initial_noise_multiplier** (float)- 高斯噪声标准偏差除以 `norm_bound` 的比率，将用于计算隐私预算。默认值：1.0。
     - **seed** (int)- 原始随机种子，如果seed=0随机正态将使用安全随机数。如果seed!=0随机正态将使用给定的种子生成值。默认值：0。
     - **decay_policy** (str)- 衰减策略。默认值：None。
 
     .. py:method:: construct(gradients)
 
-        产生的高斯噪声。
+        产生高斯噪声。
 
         **参数：**
 
@@ -34,14 +34,14 @@ mindarmour.privacy.diff_privacy
     **参数：**
 
     - **norm_bound** (float) - 梯度的l2范数的裁剪范围。默认值：1.0。
-    - **initial_noise_multiplier** (float) - 高斯噪声标准偏差除以norm_bound的比率，将用于计算隐私预算。默认值：1.0。
+    - **initial_noise_multiplier** (float) - 高斯噪声标准偏差除以 `norm_bound` 的比率，将用于计算隐私预算。默认值：1.0。
     - **seed** (int) - 原始随机种子，如果seed=0随机正态将使用安全随机数。如果seed!=0随机正态将使用给定的种子生成值。默认值：0。
     - **noise_decay_rate** (float) - 控制噪声衰减的超参数。默认值：6e-6。
     - **decay_policy** (str) - 噪声衰减策略包括'Step'、'Time'、'Exp'。默认值：'Exp'。
 
     .. py:method:: construct(gradients)
 
-        生成的自适应高斯噪声。
+        生成自适应高斯噪声。
 
         **参数：**
 
@@ -53,9 +53,10 @@ mindarmour.privacy.diff_privacy
 
 .. py:class:: mindarmour.privacy.diff_privacy.AdaClippingWithGaussianRandom(decay_policy='Linear', learning_rate=0.001, target_unclipped_quantile=0.9, fraction_stddev=0.01, seed=0)
 
-    自适应剪裁。如果 `deay_policy` 是'Linear'，则更新公式 :math:`norm\_bound = norm\_bound - learning\_rate*(beta - target\_unclipped\_quantile)` 。
+    自适应剪裁。
+    如果 `decay_policy` 是'Linear'，则更新公式为：:math:`norm\_bound = norm\_bound - learning\_rate*(beta - target\_unclipped\_quantile)` 。
 
-    如果 `deay_policy` 是'Geometric'，则更新公式为 :math:`norm\_bound = norm\_bound*exp(-learning\_rate*(empirical\_fraction - target\_unclipped\_quantile))` 。
+    如果 `decay_policy` 是'Geometric'，则更新公式为 :math:`norm\_bound = norm\_bound*exp(-learning\_rate*(empirical\_fraction - target\_unclipped\_quantile))` 。
 
     其中，beta是值最多为 `target_unclipped_quantile` 的样本的经验分数。
 
@@ -73,7 +74,7 @@ mindarmour.privacy.diff_privacy
 
     .. py:method:: construct(empirical_fraction, norm_bound)
 
-        更新norm_bound的值。
+        更新 `norm_bound` 的值。
 
         **参数：**
 
@@ -96,7 +97,7 @@ mindarmour.privacy.diff_privacy
 
         - **mech_name** (str) - 噪声生成策略，可以是'Gaussian'或'AdaGaussian'。噪声在'AdaGaussian'机制下衰减，而在'Gaussian'机制下则恒定。
         - **norm_bound** (float) - 梯度的l2范数的裁剪范围。默认值：1.0。
-        - **initial_noise_multiplier** (float) - 高斯噪声标准偏差除以norm_bound的比率，将用于计算隐私预算。默认值：1.0。
+        - **initial_noise_multiplier** (float) - 高斯噪声标准偏差除以 `norm_bound` 的比率，将用于计算隐私预算。默认值：1.0。
         - **seed** (int) - 原始随机种子，如果seed=0随机正态将使用安全随机数。如果seed!=0随机正态将使用给定的种子生成值。默认值：0。
         - **noise_decay_rate** (float) - 控制噪声衰减的超参数。默认值：6e-6。
         - **decay_policy** (str) - 衰减策略。如果decay_policy为None，则不需要更新参数。默认值：None。
@@ -147,6 +148,7 @@ mindarmour.privacy.diff_privacy
         **参数：**
 
         - **policy** (str) - 监控策略，现支持'rdp'和'zcdp'。
+
           - 如果策略为'rdp'，监控器将根据Renyi差分隐私（Renyi differential privacy，RDP）理论计算DP训练的隐私预算；
           - 如果策略为'zcdp'，监控器将根据零集中差分隐私（zero-concentrated differential privacy，zCDP）理论计算DP训练的隐私预算。注意，'zcdp'不适合子采样噪声机制。
         - **args** (Union[int, float, numpy.ndarray, list, str]) - 用于创建隐私监视器的参数。
@@ -173,8 +175,8 @@ mindarmour.privacy.diff_privacy
     - **batch_size** (int) - 训练时批处理中的样本数。
     - **initial_noise_multiplier** (Union[float, int]) - 高斯噪声标准偏差除以norm_bound的比率，将用于计算隐私预算。默认值：1.5。
     - **max_eps** (Union[float, int, None]) - DP训练的最大可接受epsilon预算，用于估计最大训练epoch。'None'表示epsilon预算没有限制。默认值：10.0。
-    - **target_delta** (Union[float, int, None]) - DP训练的目标delta预算。如果target_delta设置为δ，则隐私预算δ将在整个训练过程中是固定的。默认值：1e-3。
-    - **max_delta** (Union[float, int, None]) - DP训练的最大可接受delta预算，用于估计最大训练epoch。max_delta必须小于1，建议小于1e-3，否则会溢出。'None'表示delta预算没有限制。默认值：None。
+    - **target_delta** (Union[float, int, None]) - DP训练的目标delta预算。如果 `target_delta` 设置为δ，则隐私预算δ将在整个训练过程中是固定的。默认值：1e-3。
+    - **max_delta** (Union[float, int, None]) - DP训练的最大可接受delta预算，用于估计最大训练epoch。 `max_delta` 必须小于1，建议小于1e-3，否则会溢出。'None'表示delta预算没有限制。默认值：None。
     - **target_eps** (Union[float, int, None]) - DP训练的目标epsilon预算。如果target_eps设置为ε，则隐私预算ε将在整个训练过程中是固定的。默认值：None。
     - **orders** (Union[None, list[int, float]]) - 用于计算rdp的有限阶数，必须大于1。不同阶的隐私预算计算结果会有所不同。为了获得更严格（更小）的隐私预算估计，可以尝试阶列表。默认值：None。
     - **noise_decay_mode** (Union[None, str]) - 训练时添加噪音的衰减模式，可以是None、'Time'、'Step'、'Exp'。默认值：'Time'。
@@ -207,7 +209,7 @@ mindarmour.privacy.diff_privacy
 
     注意，ZCDPMonitor不适合子采样噪声机制（如NoiseAdaGaussianRandom和NoiseGaussianRandom）。未来将开发zCDP的匹配噪声机制。
 
-    详情请查看：  `教程 <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>`_。
+    详情请查看：`教程 <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>`_。
 
     参考文献：`Concentrated Differentially Private Gradient Descent with Adaptive per-Iteration Privacy Budget <https://arxiv.org/abs/1808.09501>`_。
 
@@ -217,7 +219,7 @@ mindarmour.privacy.diff_privacy
     - **batch_size** (int) - 训练时批处理中的样本数。
     - **initial_noise_multiplier** (Union[float, int]) - 高斯噪声标准偏差除以norm_bound的比率，将用于计算隐私预算。默认值：1.5。
     - **max_eps** (Union[float, int]) - DP训练的最大可接受epsilon预算，用于估计最大训练epoch。默认值：10.0。
-    - **target_delta** (Union[float, int]) - DP训练的目标delta预算。如果target_delta设置为δ，则隐私预算δ将在整个训练过程中是固定的。默认值：1e-3。
+    - **target_delta** (Union[float, int]) - DP训练的目标delta预算。如果 `target_delta` 设置为δ，则隐私预算δ将在整个训练过程中是固定的。默认值：1e-3。
     - **noise_decay_mode** (Union[None, str]) - 训练时添加噪音的衰减模式，可以是None、'Time'、'Step'、'Exp'。默认值：'Time'。
     - **noise_decay_rate** (float) - 训练时噪音的衰变率。默认值：6e-4。
     - **per_print_times** (int) - 计算和打印隐私预算的间隔步数。默认值：50。
@@ -265,7 +267,8 @@ mindarmour.privacy.diff_privacy
 
     .. py:method:: set_mechanisms(policy, *args, **kwargs)
 
-        获取噪音机制对象。策略可以是'Gaussian'或'AdaGaussian'。候选的args和kwargs可以在mechanisms.py的NoiseMechanismsFactory类中看到。
+        获取噪音机制对象。策略可以是'Gaussian'或'AdaGaussian'。候选的args和kwargs可以在mechanisms.py
+        的 :class:`NoiseMechanismsFactory` 类中看到。
 
         **参数：**
 
@@ -275,7 +278,7 @@ mindarmour.privacy.diff_privacy
 
     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>`_。
 
@@ -283,10 +286,13 @@ mindarmour.privacy.diff_privacy
 
     - **micro_batches** (int) - 从原始批次拆分的小批次数。默认值：2。
     - **norm_bound** (float) - 用于裁剪范围，如果设置为1，将返回原始数据。默认值：1.0。
-    - **noise_mech** (Mechanisms) - 对象可以生成不同类型的噪音。默认值：None。
-    - **clip_mech** (Mechanisms) - 该对象用于更新自适应剪裁。默认值：None。
+    - **noise_mech** (Mechanisms) - 用于生成不同类型的噪音。默认值：None。
+    - **clip_mech** (Mechanisms) - 用于更新自适应剪裁。默认值：None。
+    - **optimizer** (Cell) - 用于更新差分隐私训练过程中的模型权重值。默认值：nn.Momentum。
 
     **异常：**
 
-    - **ValueError** - DPOptimizer和noise_mech都为None或非None。
-    - **ValueError** - noise_mech或DPOtimizer的mech方法是自适应的，而clip_mech不是None。
+    - **ValueError** - optimizer值为None。
+    - **ValueError** - optimizer不是DPOptimizer，且noise_mech为None。
+    - **ValueError** - optimizer是DPOptimizer，且noise_mech非None。
+    - **ValueError** - noise_mech或DPOptimizer的mech方法是自适应的，而clip_mech不是None。

docs/api/api_python/mindarmour.privacy.evaluation.rst

@@ -5,10 +5,9 @@ mindarmour.privacy.evaluation
 
 .. py:class:: mindarmour.privacy.evaluation.MembershipInference(model, n_jobs=-1)
 
-    成员推理是由Shokri、Stronati、Song和Shmatikov提出的一种用于推断用户隐私数据的灰盒攻击。它需要训练样本的loss或logits结果。
-    （隐私是指单个用户的一些敏感属性）。
+    成员推理是由Shokri、Stronati、Song和Shmatikov提出的一种用于推断用户隐私数据的灰盒攻击。它需要训练样本的loss或logits结果，隐私是指单个用户的一些敏感属性。
 
-    有关详细信息，请参见： `教程 <https://mindspore.cn/mindarmour/docs/en/master/test_model_security_membership_inference.html>`_。
+    有关详细信息，请参见： `教程 <https://mindspore.cn/mindarmour/docs/zh-CN/master/test_model_security_membership_inference.html>`_。
 
     参考文献：`Reza Shokri, Marco Stronati, Congzheng Song, Vitaly Shmatikov. Membership Inference Attacks against Machine Learning Models. 2017. <https://arxiv.org/abs/1610.05820v2>`_。
 
@@ -19,9 +18,9 @@ mindarmour.privacy.evaluation
 
     **异常：**
 
-    - **TypeError** - 模型的类型不是Mindpore.train.Model。
-    - **TypeError** - n_jobs的类型不是int。
-    - **ValueError** - n_jobs的值既不是-1，也不是正整数。
+    - **TypeError** - 模型的类型不是 :class:`mindspore.Model` 。
+    - **TypeError** - `n_jobs` 的类型不是int。
+    - **ValueError** - `n_jobs` 的值既不是-1，也不是正整数。
 
     .. py:method:: eval(dataset_train, dataset_test, metrics)
 
@@ -42,14 +41,11 @@ mindarmour.privacy.evaluation
 
         根据配置，使用输入数据集训练攻击模型。
 
-        将攻击模型保存至self._attack_list。
-
         **参数：**
 
         - **dataset_train** (minspore.dataset) - 目标模型的训练数据集。
         - **dataset_test** (minspore.dataset) - 目标模型的测试集。
         - **attack_config** (Union[list, tuple]) - 攻击模型的参数设置。格式为
-
             .. code-block:: python
 
                 attack_config =
@@ -57,19 +53,20 @@ mindarmour.privacy.evaluation
                      {"method": "lr", "params": {"C": np.logspace(-4, 2, 10)}}]
 
           - 支持的方法有knn、lr、mlp和rf，每个方法的参数必须在可变参数的范围内。参数实现的提示可在下面找到：
-            - `KNN <https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html>`_,
-            - `LR <https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html>`_,
-            - `RF <https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html>`_,
-            - `MLP <https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html>`_.
+
+            - `KNN <https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html>`_
+            - `LR <https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html>`_
+            - `RF <https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html>`_
+            - `MLP <https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html>`_
 
         **异常：**
 
-        - **KeyError** - attack_config中的配置没有键{"method", "params"}。
-        - **NameError** - attack_config中的方法（不区分大小写）不在["lr", "knn", "rf", "mlp"]中。
+        - **KeyError** - `attack_config` 中的配置没有键{"method", "params"}。
+        - **NameError** - `attack_config` 中的方法（不区分大小写）不在["lr", "knn", "rf", "mlp"]中。
 
 .. py:class:: mindarmour.privacy.evaluation.ImageInversionAttack(network, input_shape, input_bound, loss_weights=(1, 0.2, 5))
 
-    一种用于通过还原图像的深层表达来重建图像的攻击方法。
+    一种通过还原图像的深层表达来重建图像的攻击方法。
 
     参考文献：`Aravindh Mahendran, Andrea Vedaldi. Understanding Deep Image Representations by Inverting Them. 2014. <https://arxiv.org/pdf/1412.0035.pdf>`_。
 
@@ -83,8 +80,8 @@ mindarmour.privacy.evaluation
     **异常：**
 
     - **TypeError** - 网络类型不是Cell。
-    - **ValueError** - input_shape的值都不是正int。
-    - **ValueError** - loss_weights的值都不是正值。
+    - **ValueError** - `input_shape` 的值有非正整数。
+    - **ValueError** - `loss_weights` 的值有非正数。
 
     .. py:method:: evaluate(original_images, inversion_images, labels=None, new_network=None)
 
@@ -95,17 +92,17 @@ mindarmour.privacy.evaluation
         - **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。
+        - **new_network** (Cell) - 其结构包含self._network中所有网络，但加载了不同的模型文件。默认值：None。
 
         **返回：**
 
         - **float** - l2距离。
         - **float** - 平均ssim值。
-        - **Union[float, None]** - 平均置信度。如果labels或new_network为 None，则该值为None。
+        - **Union[float, None]** - 平均置信度。如果 `labels` 或 `new_network` 为None，则该值为None。
 
     .. py:method:: generate(target_features, iters=100)
 
-        根据target_features重建图像。
+        根据 `target_features` 重建图像。
 
         **参数：**
 
@@ -119,5 +116,5 @@ mindarmour.privacy.evaluation
         **异常：**
 
         - **TypeError** - target_features的类型不是numpy.ndarray。
-        - **ValueError** - iters的值都不是正int.Z
+        - **ValueError** - `iters` 的值都不是正整数.
 

docs/api/api_python/mindarmour.privacy.sup_privacy.rst

@@ -13,7 +13,7 @@ mindarmour.privacy.sup_privacy
     **参数：**
 
     - **model** (SuppressModel) - SuppressModel 实例。
-    - **suppress_ctrl** (SuppressCtrl) - SuppressCtrl实例。
+    - **suppress_ctrl** (SuppressCtrl) - SuppressCtrl 实例。
 
     .. py:method:: step_end(run_context)
 
@@ -25,14 +25,14 @@ mindarmour.privacy.sup_privacy
 
 .. py:class:: mindarmour.privacy.sup_privacy.SuppressModel(network, loss_fn, optimizer, **kwargs)
 
-    完整的模型训练功能。抑制隐私函数嵌入到重载的mindspore.train.model.Model中。
+    抑制隐私训练器，重载自 :class:`mindspore.Model` 。
 
     有关详细信息，请查看： `应用抑制隐私机制保护用户隐私 <https://mindspore.cn/mindarmour/docs/zh-CN/master/protect_user_privacy_with_suppress_privacy.html>`_。
 
     **参数：**
 
     - **network** (Cell) - 要训练的神经网络模型。
-    - **loss_fn** (Cell) - 计算logits和labels之间的softmax交叉熵。
+    - **loss_fn** (Cell) - 优化器的损失函数。
     - **optimizer** (Optimizer) - 优化器实例。
     - **kwargs** - 创建抑制模型时使用的关键字参数。
 
@@ -80,7 +80,7 @@ mindarmour.privacy.sup_privacy
     - **networks** (Cell) - 要训练的神经网络模型。
     - **mask_layers** (list) - 需要抑制的层的描述。
     - **end_epoch** (int) - 最后一次抑制操作对应的epoch序号。
-    - **batch_num** (int) - 一个epoch中的grad操作的数量。
+    - **batch_num** (int) - 一个epoch中的batch数量。
     - **start_epoch** (int) - 第一个抑制操作对应的epoch序号。
     - **mask_times** (int) - 抑制操作的数量。
     - **lr** (Union[float, int]) - 学习率。
@@ -114,7 +114,7 @@ mindarmour.privacy.sup_privacy
 
     .. py:method:: calc_theoretical_sparse_for_conv()
 
-        计算con1层和con2层的掩码矩阵的实际稀疏性。
+        计算卷积层的掩码矩阵的实际稀疏性。
 
     .. py:method:: print_paras()
 
@@ -171,7 +171,7 @@ mindarmour.privacy.sup_privacy
 
 .. py:class:: mindarmour.privacy.sup_privacy.MaskLayerDes(layer_name, grad_idx, is_add_noise, is_lower_clip, min_num, upper_bound=1.20)
 
-    描述需要抑制的层。
+    对抑制目标层的描述。
 
     **参数：**
 
@@ -181,9 +181,9 @@ mindarmour.privacy.sup_privacy
             for layer in networks.get_parameters(expand=True):
                 if layer.name == "conv": ...
 
-    - **grad_idx** (int) - Grad层索引，在grad元组中获取掩码层的索引。您可以参考mindarmour/privacy/sup_privacy/train/model.py中TrainOneStepCell的构造函数，获取某些指定的grad层的索引（在PYNATIVE_MODE中打印）。
-    - **is_add_noise** (bool) - 如果为True，则此层的权重可以添加噪声。如果为False，则此层的权重不能添加噪声。如果参数num大于100000，则is_add_noise无效。
+    - **grad_idx** (int) - 掩码层在梯度元组中的索引。可参考 `model.py <https://gitee.com/mindspore/mindarmour/blob/master/mindarmour/privacy/sup_privacy/train/model.py>`_ 中TrainOneStepCell的构造函数，在PYNATIVE_MODE模式下打印某些层的索引值。
+    - **is_add_noise** (bool) - 如果为True，则此层的权重可以添加噪声。如果为False，则此层的权重不能添加噪声。如果参数num大于100000，则　`is_add_noise` 无效。
     - **is_lower_clip** (bool) - 如果为True，则此层的权重将被剪裁到大于下限值。如果为False，此层的权重不会被要求大于下限制。如果参数num大于100000，则is_lower_clip无效。
-    - **min_num** (int) - 未抑制的剩余权重数。如果min_num小于（参数num*SupperssCtrl.sparse_end），则min_num无效。
+    - **min_num** (int) - 未抑制的剩余权重数。如果min_num小于（参数总数量 *　`SupperssCtrl.sparse_end` ），则min_num无效。
     - **upper_bound** (Union[float, int]) - 此层权重的最大abs值，默认值：1.20。如果参数num大于100000，则upper_bound无效。
 

docs/api/api_python/mindarmour.rst

@@ -228,19 +228,21 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
     **参数：**
 
     - **micro_batches** (int) - 从原始批次拆分的小批次数。默认值：2。
-    - **norm_bound** (float) - 用于剪裁的约束，如果设置为1，将返回原始数据。默认值：1.0。
-    - **noise_mech** (Mechanisms) - 对象可以生成不同类型的噪音。默认值：None。
-    - **clip_mech** (Mechanisms) - 该对象用于更新自适应剪裁。默认值：None。
-    - **optimizer** (Cell) - 差分隐私训练用到的优化器，可以是MindSpore提供的原装优化器或者'DPOptimizerClassFatory'构造的差分隐私优化器。默认值：None。
+    - **norm_bound** (float) - 用于裁剪的约束，如果设置为1，将返回原始数据。默认值：1.0。
+    - **noise_mech** (Mechanisms) - 用于生成不同类型的噪音。默认值：None。
+    - **clip_mech** (Mechanisms) - 用于更新自适应剪裁。默认值：None。
+    - **optimizer** (Cell) - 用于更新差分隐私训练过程中的模型权重值。默认值：nn.Momentum。
 
     **异常：**
 
-    - **ValueError** - `optimizer` 和 `noise_mech` 都为None或都为非None。
-    - **ValueError** - `noise_mech` 或 `optimizer` 的'mech'方法是自适应的，而clip_mech不是None。
+    - **ValueError** - `optimizer` 值为None。
+    - **ValueError** - `optimizer` 不是DPOptimizer，且 `noise_mech` 为None。
+    - **ValueError** - `optimizer` 是DPOptimizer，且 `noise_mech` 非None。
+    - **ValueError** - `noise_mech` 或DPOptimizer的mech方法是自适应的，而 `clip_mech` 不是None。
 
 .. py:class:: mindarmour.MembershipInference(model, n_jobs=-1)
 
-    成员推理是由Shokri、Stronati、Song和Shmatikov提出的一种用于推测用户隐私数据的灰盒攻击。它需要训练样本的loss或logits结果。（隐私是指单个用户的一些敏感属性）。
+    成员推理是由Shokri、Stronati、Song和Shmatikov提出的一种用于推测用户隐私数据的灰盒攻击。它需要训练样本的loss或logits结果，隐私是指单个用户的一些敏感属性。
 
     有关详细信息，请参见：`使用成员推理测试模型安全性 <https://mindspore.cn/mindarmour/docs/zh-CN/master/test_model_security_membership_inference.html>`_。
 
@@ -254,8 +256,8 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
     **异常：**
 
     - **TypeError** - 模型的类型不是Mindspore.Model。
-    - **TypeError** - n_jobs的类型不是int。
-    - **ValueError** - n_jobs的值既不是-1，也不是正整数。
+    - **TypeError** - `n_jobs` 的类型不是int。
+    - **ValueError** - `n_jobs` 的值既不是-1，也不是正整数。
 
     .. py:method:: eval(dataset_train, dataset_test, metrics)
 
@@ -276,8 +278,6 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
         根据配置，使用输入数据集训练攻击模型。
 
-        将攻击模型保存至self._attack_list。
-
         **参数：**
 
         - **dataset_train** (minspore.dataset) - 目标模型的训练数据集。
@@ -290,19 +290,20 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
                      {"method": "lr", "params": {"C": np.logspace(-4, 2, 10)}}]
 
           - 支持的方法有knn、lr、mlp和rf，每个方法的参数必须在可变参数的范围内。参数实现的提示可在下面找到：
-            - `KNN <https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html>`_ ，
-            - `LR <https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html>`_ ，
-            - `RF <https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html>`_ ，
-            - `MLP <https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html>`_ 。
+
+            - `KNN <https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html>`_
+            - `LR <https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html>`_
+            - `RF <https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html>`_
+            - `MLP <https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPRegressor.html>`_
 
         **异常：**
 
-        - **KeyError** - attack_config中的配置没有键{"method", "params"}。
-        - **NameError** - attack_config中的方法（不区分大小写）不在["lr", "knn", "rf", "mlp"]中。
+        - **KeyError** - `attack_config` 中的配置没有键{"method", "params"}。
+        - **NameError** - `attack_config` 中的方法（不区分大小写）不在["lr", "knn", "rf", "mlp"]中。
 
 .. py:class:: mindarmour.ImageInversionAttack(network, input_shape, input_bound, loss_weights=(1, 0.2, 5))
 
-    一种用于通过还原图像的深层表达来重建图像的攻击方法。
+    一种通过还原图像的深层表达来重建图像的攻击方法。
 
     参考文献：`Aravindh Mahendran, Andrea Vedaldi. Understanding Deep Image Representations by Inverting Them. 2014. <https://arxiv.org/pdf/1412.0035.pdf>`_。
 
@@ -316,8 +317,8 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
     **异常：**
 
     - **TypeError** - 网络类型不是Cell。
-    - **ValueError** - `input_shape` 的值都不是正int。
-    - **ValueError** - `loss_weights` 的值都不是正值。
+    - **ValueError** - `input_shape` 的值有非正整数。
+    - **ValueError** - `loss_weights` 的值有非正数。
 
     .. py:method:: evaluate(original_images, inversion_images, labels=None, new_network=None)
 
@@ -327,8 +328,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所有部分的网络，但加载了不同的模型文件。默认值：None。
+        - **labels** (numpy.ndarray) - 原始图像的ground truth标签。默认值：None。
+        - **new_network** (Cell) - 其结构包含self._network中所有网络，但加载了不同的模型文件。默认值：None。
 
         **返回：**
 
@@ -338,7 +339,7 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
     .. py:method:: generate(target_features, iters=100)
 
-        根据target_features重建图像。
+        根据 `target_features` 重建图像。
 
         **参数：**
 
@@ -352,8 +353,8 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
 
         **异常：**
 
-        - **TypeError** - `target_features` 的类型不是numpy.ndarray。
-        - **ValueError** - `iters` 的值都不是正int.Z
+        - **TypeError** - target_features的类型不是numpy.ndarray。
+        - **ValueError** - `iters` 的有非正整数.
 
 .. py:class:: mindarmour.ConceptDriftCheckTimeSeries(window_size=100, rolling_window=10, step=10, threshold_index=1.5, need_label=False)
 
@@ -366,7 +367,7 @@ MindArmour是MindSpore的工具箱，用于增强模型可信，实现隐私保
     - **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。
-    - **threshold_index** (float) - 阈值索引，:math:`(-\infty, +\infty)`。默认值：1.5。
+    - **threshold_index** (float) - 阈值索引，:math:`(-\infty, +\infty)` 。默认值：1.5。
     - **need_label** (bool) - False或True。如果need_label=True，则需要概念漂移标签。默认值：False。
 
     .. py:method:: concept_check(data)

mindarmour/privacy/diff_privacy/train/model.py

@@ -82,15 +82,20 @@ class DPModel(Model):
             noise. Default: None.
         clip_mech (Mechanisms): The object is used to update the adaptive clip.
             Default: None.
+        optimizer (Cell): Optimizer used for differential privacy training, which can be original mindspore
+            optimizers (for example, Momentum optimizer) or optimizers generated by DPOptimizerClassFactory.
+            Default: nn.Momentum.
 
     Raises:
-        ValueError: If DPOptimizer and noise_mech are both None or not None.
-        ValueError: If noise_mech or DPOtimizer's mech method is adaptive while clip_mech is not None.
+        ValueError: If optimizer is None.
+        ValueError: If optimizer is not DPOptimizer and noise_mech is None.
+        ValueError: If optimizer is DPOptimizer and noise_mech is not None.
+        ValueError: If noise_mech or DPOptimizer's mech method is adaptive while clip_mech is not None.
 
     """
 
     def __init__(self, micro_batches=2, norm_bound=1.0, noise_mech=None,
-                 clip_mech=None, **kwargs):
+                 clip_mech=None, optimizer=nn.Momentum, **kwargs):
         if micro_batches:
             self._micro_batches = check_int_positive('micro_batches',
                                                      micro_batches)
@@ -100,9 +105,11 @@ class DPModel(Model):
         norm_bound = check_value_positive('norm_bound', norm_bound)
         norm_bound = Tensor(norm_bound, mstype.float32)
         self._norm_bound = Parameter(norm_bound, 'norm_bound')
-
-        opt = kwargs['optimizer']
-        opt_name = opt.__class__.__name__
+        if optimizer is None:
+            msg = 'Optimizer need to be set, but got None.'
+            LOGGER.error(TAG, msg)
+            raise ValueError(msg)
+        opt_name = optimizer.__class__.__name__
         # Check whether noise_mech and DPOptimizer are both None or not None, if so, raise ValueError.
         # And check whether noise_mech or DPOtimizer's mech method is adaptive while clip_mech is not None,
         # if so, raise ValuerError too.
@@ -112,7 +119,7 @@ class DPModel(Model):
             raise ValueError(msg)
         if noise_mech is None:
             if "DPOptimizer" in opt_name:
-                if 'Ada' in opt._mech.__class__.__name__ and clip_mech is not None:
+                if 'Ada' in optimizer._mech.__class__.__name__ and clip_mech is not None:
                     msg = "When DPOptimizer's mech method is adaptive, clip_mech must be None."
                     LOGGER.error(TAG, msg)
                     raise ValueError(msg)

mindarmour/privacy/evaluation/membership_inference.py

@@ -95,8 +95,8 @@ def _softmax_cross_entropy(logits, labels, epsilon=1e-12):
 class MembershipInference:
     """
     Proposed by Shokri, Stronati, Song and Shmatikov, membership inference is a grey-box attack
-    for inferring user's privacy data. It requires loss or logits results of the training samples.
-    (Privacy refers to some sensitive attributes of a single user).
+    for inferring user's privacy data. It requires loss or logits results of the training samples. Privacy refers
+    to some sensitive attributes of a single user.
 
     For details, please refer to the `Using Membership Inference to Test Model Security
     <https://mindspore.cn/mindarmour/docs/en/master/test_model_security_membership_inference.html>`_.
@@ -171,7 +171,6 @@ class MembershipInference:
     def train(self, dataset_train, dataset_test, attack_config):
         """
         Depending on the configuration, use the input dataset to train the attack model.
-        Save the attack model to self._attack_list.
 
         Args:
             dataset_train (mindspore.dataset): The training dataset for the target model.

mindarmour/privacy/sup_privacy/sup_ctrl/conctrl.py

@@ -53,7 +53,7 @@ class SuppressPrivacyFactory:
             policy (str): Training policy for suppress privacy training. Default: "local_train", means local training.
             end_epoch (int): The last epoch in suppress operations, 0<start_epoch<=end_epoch<=100. Default: 10.
                 This end_epoch parameter should be same as 'epoch' parameter of mindspore.train.model.train().
-            batch_num (int): The num of batch in an epoch, should be equal to num_samples/batch_size. Default: 20.
+            batch_num (int): The num of batches in an epoch, should be equal to num_samples/batch_size. Default: 20.
             start_epoch (int): The first epoch in suppress operations, 0<start_epoch<=end_epoch<=100. Default: 3.
             mask_times (int): The num of suppress operations. Default: 1000.
             lr (Union[float, int]): Learning rate, should be unchanged during training. 0<lr<=0.50. Default: 0.05.
@@ -772,9 +772,9 @@ class MaskLayerDes:
                 for layer in networks.get_parameters(expand=True):
                     if layer.name == "conv": ...
 
-        grad_idx (int): Grad layer index, get mask layer's index in grad tuple.You can refer to the construct function
-            of TrainOneStepCell in mindarmour/privacy/sup_privacy/train/model.py to get the index of some specified
-            grad layers (print in PYNATIVE_MODE).
+        grad_idx (int): Mask layer's index in grad tuple.You can refer to the construct function
+            of TrainOneStepCell in mindarmour/privacy/sup_privacy/train/model.py to print the index of some specified
+            grad layers in PYNATIVE_MODE.
         is_add_noise (bool): If True, the weight of this layer can add noise.
             If False, the weight of this layer can not add noise.
             If parameter num is greater than 100000, is_add_noise has no effect.

mindarmour/privacy/sup_privacy/train/model.py

@@ -56,15 +56,14 @@ def tensor_grad_scale(scale, grad):
 
 class SuppressModel(Model):
     """
-    Complete model train function. The suppress privacy function is embedded into the overload
-    mindspore.train.model.Model.
+    Suppress privacy training model, which is overload from mindspore.train.model.Model.
 
     For details, please check `Protecting User Privacy with Suppress Privacy
     <https://mindspore.cn/mindarmour/docs/en/master/protect_user_privacy_with_suppress_privacy.html>`_.
 
     Args:
         network (Cell): The training network.
-        loss_fn (Cell): Computes softmax cross entropy between logits and labels.
+        loss_fn (Cell): Loss function of optimizers.
         optimizer (Optimizer): optimizer instance.
         kwargs: Keyword parameters used for creating a suppress model.
     """