!31033 modify content order in rst file for mastet part3

Merge pull request !31033 from lvmingfu/master

docs/api/api_python/mindspore.boost.rst

@@ -5,27 +5,6 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
 
 注：此特性为测试版本，我们仍在改进其功能。
 
-.. py:class:: mindspore.boost.AdaSum(rank, device_number, group_number, parameter_tuple)
-
-    Adaptive Summation(AdaSum)是一种优化深度学习模型并行训练的算法，它可以提升不同规模集群训练的精度，减小不同规模集群调参难度。
-
-    **参数：**
-
-    - **rank** (int) – 总的训练的卡数。
-    - **device_number** (int) – 单机的卡数。
-    - **group_number** (int) – 分组的数量。
-    - **parameter_tuple** (Tuple(Parameter)) – 网络训练权重组成的元组。
-
-    **输入：**
-
-    - **delta_weights** (Tuple(Tensor)) – 梯度tuple。
-    - **parameters** (Tuple(Parameter)) – 当前权重组成的元组。
-    - **old_parameters** (Tuple(Parameter)) – 旧的权重组成的元组。
-
-    **输出：**
-
-    - **Tuple** (Tensor) - adasum处理后更新的权重。
-
 .. py:class:: mindspore.boost.AutoBoost(level="O0", boost_config_dict="")
 
     MindSpore自动优化算法库。
@@ -163,6 +142,14 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
 
     - **ValueError** – Boost的模式不在["auto", "manual", "enable_all", "disable_all"]这个列表中。
 
+    .. py:method:: network_auto_process_eval(network)
+    
+        使用Boost算法推理。
+    
+        **参数：**
+    
+        **network** (Cell) - 推理网络。
+
     .. py:method:: network_auto_process_train(network, optimizer)
     
         使用Boost算法训练。
@@ -171,14 +158,65 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
     
         - **network** (Cell) - 训练网络。
         - **optimizer** (Union[Cell]) - 用于更新权重的优化器。
-    
-    .. py:method:: network_auto_process_eval(network)
-    
-        使用Boost算法推理。
-    
+
+.. py:class:: mindspore.boost.OptimizerProcess(opt)
+
+    处理Boost的优化器，目前支持给优化器添加梯度中心化和创建新的优化器。
+
+    **参数：**
+
+    - **opt** (Cell) – 使用的优化器。
+
+    .. py:method:: add_grad_centralization(network)
+
+        添加梯度中心化。
+
+        **参数：**
+
+        - **network** (Cell) – 训练网络。
+
+    .. py:method:: build_gc_params_group(params_dict, parameters)
+
+        构建网络权重的dict。
+
+        **参数：**
+
+        - **params_dict** (dict) – 训练权重的字典。
+        - **parameters** (list) – 训练权重的列表。
+
+    .. py:method:: build_params_dict(network)
+
+        构建网络权重的dict。
+
+        **参数：**
+
+        - **network** (Cell) – 训练网络。
+
+    .. py:method:: generate_new_optimizer()
+
+        生成新的优化器。
+
+.. py:class:: mindspore.boost.ParameterProcess()
+
+    处理Boost网络的权重。当前支持创建分组参数和自动设置网络梯度切分点。
+
+    .. py:method:: assign_parameter_group(parameters, split_point=None)
+
+        设置分组权重。
+
         **参数：**
-    
-        **network** (Cell) - 推理网络。
+
+        - **parameters** (list) – 训练网络的权重。
+        - **split_point** (list) – 网络梯度切分点。默认为None。
+
+    .. py:method:: generate_group_params(parameters, origin_params)
+
+        创建分组权重。
+
+        **参数：**
+
+        - **parameters** (list) – 训练网络的新权重。
+        - **origin_params** (list) –  训练网络的初始权重。
 
 .. py:class:: mindspore.boost.BoostTrainOneStepCell(network, optimizer, sens=1.0)
 
@@ -209,18 +247,35 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
 
     - **TypeError** – 如果*sens*不是一个数字。
 
-    .. py:method:: gradient_freeze_process(*inputs)
+    .. py:method:: adasum_process(loss, grads)
     
-        使用梯度冻结算法训练。
+        使用Adasum算法训练。
 
         **参数：**
 
-        - **inputs** (Tuple(Tensor)) – 网络训练的输入。
+        - **loss** (Tensor) – 网络训练的loss值。
+        - **grads** (Tuple(Tensor)) – 网络训练过程中的梯度。
     
         **返回：**
     
         number，网络训练过程中得到的loss值。
     
+    .. py:method:: check_adasum_enable()
+    
+        Adasum算法仅在多卡或者多机场景生效，并且要求卡数符合2的n次方，该函数用来判断adasum算法能否生效。
+    
+        **返回：**
+    
+        enable_adasum (bool)，Adasum算法是否生效。
+    
+    .. py:method:: check_dim_reduce_enable()
+    
+        使用降维二阶训练算法训练。
+    
+        **返回：**
+    
+        enable_dim_reduce (bool)，降维二阶训练算法是否生效。
+
     .. py:method:: gradient_accumulation_process(loss, grads, sens, *inputs)
     
         使用梯度累积算法训练。
@@ -235,35 +290,18 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
         **返回：**
     
         number，网络训练过程中得到的loss值。
+
+    .. py:method:: gradient_freeze_process(*inputs)
     
-    .. py:method:: adasum_process(loss, grads)
-    
-        使用Adasum算法训练。
+        使用梯度冻结算法训练。
 
         **参数：**
 
-        - **loss** (Tensor) – 网络训练的loss值。
-        - **grads** (Tuple(Tensor)) – 网络训练过程中的梯度。
+        - **inputs** (Tuple(Tensor)) – 网络训练的输入。
     
         **返回：**
     
         number，网络训练过程中得到的loss值。
-    
-    .. py:method:: check_adasum_enable()
-    
-        Adasum算法仅在多卡或者多机场景生效，并且要求卡数符合2的n次方，该函数用来判断adasum算法能否生效。
-    
-        **返回：**
-    
-        enable_adasum (bool)，Adasum算法是否生效。
-    
-    .. py:method:: check_dim_reduce_enable()
-    
-        使用降维二阶训练算法训练。
-    
-        **返回：**
-    
-        enable_dim_reduce (bool)，降维二阶训练算法是否生效。
 
 .. py:class:: mindspore.boost.BoostTrainOneStepWithLossScaleCell(network, optimizer, scale_sense)
 
@@ -295,66 +333,14 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
     - **TypeError** - `scale_sense` 既不是Cell，也不是Tensor。
     - **ValueError** - `scale_sense` 的shape既不是(1,)也不是()。
 
-.. py:class:: mindspore.boost.DimReduce(network, optimizer, weight, pca_mat_local, n_components, rho, gamma, alpha, sigma, rank, rank_size)
-
-    降维训练(dimension reduce training)是一种优化深度学习模型训练的算法，它可以加速模型的收敛。
-
-    算法主要原理：
-
-    .. math::
-
-        \begin{align}
-        grad\_k &= pca\_mat \cdot grad\\
-        dk &= - bk \cdot grad\_k\\
-        sk &= rho ^ m \cdot dk\\
-        delta\_loss &= sigma \cdot grad\_k.T \cdot sk
-        \end{align}
-
-    其中:
-
-    - pca_mat (array): 维度(k*n)，k是n_components的大小，n是权重的大小。
-    - bk (array): 维度(k*k)，bk是拟牛顿法中的对称正定矩阵。
-
-    我们需要找到满足以下条件的m:
-
-    .. math::
-        new\_loss < old\_loss + delta\_loss
-
-    然后使用delta_grad去更新模型的权重:
-
-    .. math::
+.. py:class:: mindspore.boost.LessBN(network, fn_flag=False)
 
-        \begin{align}
-        grad\_k\_proj &= pca\_mat.T \cdot grad\_k\\
-        new\_grad\_momentum &= gamma \cdot old\_grad\_momentum + grad - grad\_k\_proj\\
-        delta\_grad &= alpha \cdot new\_grad\_momentum - pca\_mat.T \cdot sk
-        \end{align}
+    LessBN算法，可以在不损失网络精度的前提下，自动减少网络中批归一化（Batch Normalization）的数量，来提升网络性能。
 
     **参数：**
 
-    - **network** (Cell) - 训练网络，只支持单输出。
-    - **optimizer** (Union[Cell]) - 更新权重的优化器。
-    - **weight** (Tuple(Parameter)) - 网络权重组成的元组。
-    - **pca_mat_local** (numpy.ndarray) - 用于PCA操作的，经过切分的PCA转换矩阵，维度为k*n，k是切分的n_components的大小，n是权重的大小。
-    - **n_components** (int) - PCA的主成分维度(components)。
-    - **rho** (float) - 超参。
-    - **gamma** (float) - 超参。
-    - **alpha** (float) - 超参。
-    - **sigma** (float) - 超参。
-    - **rank** (int) - Rank编号。
-    - **rank_size** (int) - Rank总数。
-
-    **输入：**
-
-    - **loss** (Tensor) - 标量Tensor。
-    - **old_grad** (Tuple(Tensor)) - 网络权重提取组成的元组。
-    - **weight** (Tuple(Tensor)) - 网络权重组成的元组。
-    - **weight_clone** (Tuple(Tensor)) - 网络权重的副本。
-    - **(\*inputs)** (Tuple(Tensor)) - 网络的所有输入组成的元组。
-
-    **输出：**
-
-    - **loss** (Tensor) - 标量Tensor。
+    - **network** (Cell) – 待训练的网络模型。
+    - **fn_flag** (bool) – 是否将网络中最后一个全连接层替换为全归一化层。默认值：False。
 
 .. py:class:: mindspore.boost.GradientFreeze(param_groups, freeze_type, freeze_p, total_steps)
 
@@ -368,6 +354,15 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
     - **freeze_p** (float) – 梯度冻结训练的概率。
     - **total_steps** (numbers.Number) – 整个训练过程的总的步数。
 
+    .. py:method:: freeze_generate(network, optimizer)
+
+        生成梯度冻结的网络与优化器。
+
+        **参数：**
+
+        - **network** (Cell) – 训练网络。
+        - **optimizer** (Union[Cell]) – 用于更新权重的优化器。
+
     .. py:method:: generate_freeze_index_sequence(parameter_groups_number, freeze_strategy, freeze_p, total_steps)
 
         生成梯度冻结每一步需要冻结的层数。
@@ -388,14 +383,15 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
         - **net** (Cell) – 训练网络。
         - **freeze_para_groups_number** (numbers.Number) – 梯度冻结训练的权重个数。
 
-    .. py:method:: freeze_generate(network, optimizer)
+.. py:class:: mindspore.boost.FreezeOpt(opt, train_parameter_groups=None, train_strategy=None)
 
-        生成梯度冻结的网络与优化器。
+    支持梯度冻结训练的优化器。
 
-        **参数：**
+    **参数：**
 
-        - **network** (Cell) – 训练网络。
-        - **optimizer** (Union[Cell]) – 用于更新权重的优化器。
+    - **opt** (Cell) – 非冻结优化器实例，如*Momentum*，*SGD*。
+    - **train_parameter_groups** (Union[tuple, list]) – 梯度冻结训练的权重。
+    - **train_strategy** (Union[tuple(int), list(int), Tensor]) – 梯度冻结训练的策略。
 
 .. py:function:: freeze_cell(reducer_flag, network, optimizer, sens, grad, use_grad_accumulation, mean=None, degree=None, max_accumulation_step=1)
 
@@ -413,16 +409,6 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
     - **degree** (int): device卡数。默认值为None。
     - **max_accumulation_step** (int): 梯度累积步数。默认值为1。
 
-.. py:class:: mindspore.boost.FreezeOpt(opt, train_parameter_groups=None, train_strategy=None)
-
-    支持梯度冻结训练的优化器。
-
-    **参数：**
-
-    - **opt** (Cell) – 非冻结优化器实例，如*Momentum*，*SGD*。
-    - **train_parameter_groups** (Union[tuple, list]) – 梯度冻结训练的权重。
-    - **train_strategy** (Union[tuple(int), list(int), Tensor]) – 梯度冻结训练的策略。
-
 .. py:class:: mindspore.boost.GradientAccumulation(max_accumulation_step, optimizer)
 
     梯度累积算法，在累积多个step的梯度之后，再用来更新网络权重，可以提高训练效率。
@@ -432,73 +418,87 @@ Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。
     - **max_accumulation_step** (int) – 累积梯度的步数。
     - **optimizer** (Cell) – 网络训练使用的优化器。
 
-.. py:class:: mindspore.boost.LessBN(network, fn_flag=False)
-
-    LessBN算法，可以在不损失网络精度的前提下，自动减少网络中批归一化（Batch Normalization）的数量，来提升网络性能。
-
-    **参数：**
-
-    - **network** (Cell) – 待训练的网络模型。
-    - **fn_flag** (bool) – 是否将网络中最后一个全连接层替换为全归一化层。默认值：False。
-
-.. py:class:: mindspore.boost.OptimizerProcess(opt)
+.. py:class:: mindspore.boost.AdaSum(rank, device_number, group_number, parameter_tuple)
 
-    处理Boost的优化器，目前支持给优化器添加梯度中心化和创建新的优化器。
+    Adaptive Summation(AdaSum)是一种优化深度学习模型并行训练的算法，它可以提升不同规模集群训练的精度，减小不同规模集群调参难度。
 
     **参数：**
 
-    - **opt** (Cell) – 使用的优化器。
-
-    .. py:method:: add_grad_centralization(network)
-
-        添加梯度中心化。
+    - **rank** (int) – 总的训练的卡数。
+    - **device_number** (int) – 单机的卡数。
+    - **group_number** (int) – 分组的数量。
+    - **parameter_tuple** (Tuple(Parameter)) – 网络训练权重组成的元组。
 
-        **参数：**
+    **输入：**
 
-        - **network** (Cell) – 训练网络。
+    - **delta_weights** (Tuple(Tensor)) – 梯度tuple。
+    - **parameters** (Tuple(Parameter)) – 当前权重组成的元组。
+    - **old_parameters** (Tuple(Parameter)) – 旧的权重组成的元组。
 
-    .. py:method:: build_params_dict(network)
+    **输出：**
 
-        构建网络权重的dict。
+    - **Tuple** (Tensor) - adasum处理后更新的权重。
 
-        **参数：**
+.. py:class:: mindspore.boost.DimReduce(network, optimizer, weight, pca_mat_local, n_components, rho, gamma, alpha, sigma, rank, rank_size)
 
-        - **network** (Cell) – 训练网络。
+    降维训练(dimension reduce training)是一种优化深度学习模型训练的算法，它可以加速模型的收敛。
 
-    .. py:method:: build_gc_params_group(params_dict, parameters)
+    算法主要原理：
 
-        构建网络权重的dict。
+    .. math::
 
-        **参数：**
+        \begin{align}
+        grad\_k &= pca\_mat \cdot grad\\
+        dk &= - bk \cdot grad\_k\\
+        sk &= rho ^ m \cdot dk\\
+        delta\_loss &= sigma \cdot grad\_k.T \cdot sk
+        \end{align}
 
-        - **params_dict** (dict) – 训练权重的字典。
-        - **parameters** (list) – 训练权重的列表。
+    其中:
 
-    .. py:method:: generate_new_optimizer()
+    - pca_mat (array): 维度(k*n)，k是n_components的大小，n是权重的大小。
+    - bk (array): 维度(k*k)，bk是拟牛顿法中的对称正定矩阵。
 
-        生成新的优化器。
+    我们需要找到满足以下条件的m:
 
-.. py:class:: mindspore.boost.ParameterProcess()
+    .. math::
+        new\_loss < old\_loss + delta\_loss
 
-    处理Boost网络的权重。当前支持创建分组参数和自动设置网络梯度切分点。
+    然后使用delta_grad去更新模型的权重:
 
-    .. py:method:: assign_parameter_group(parameters, split_point=None)
+    .. math::
 
-        设置分组权重。
+        \begin{align}
+        grad\_k\_proj &= pca\_mat.T \cdot grad\_k\\
+        new\_grad\_momentum &= gamma \cdot old\_grad\_momentum + grad - grad\_k\_proj\\
+        delta\_grad &= alpha \cdot new\_grad\_momentum - pca\_mat.T \cdot sk
+        \end{align}
 
-        **参数：**
+    **参数：**
 
-        - **parameters** (list) – 训练网络的权重。
-        - **split_point** (list) – 网络梯度切分点。默认为None。
+    - **network** (Cell) - 训练网络，只支持单输出。
+    - **optimizer** (Union[Cell]) - 更新权重的优化器。
+    - **weight** (Tuple(Parameter)) - 网络权重组成的元组。
+    - **pca_mat_local** (numpy.ndarray) - 用于PCA操作的，经过切分的PCA转换矩阵，维度为k*n，k是切分的n_components的大小，n是权重的大小。
+    - **n_components** (int) - PCA的主成分维度(components)。
+    - **rho** (float) - 超参。
+    - **gamma** (float) - 超参。
+    - **alpha** (float) - 超参。
+    - **sigma** (float) - 超参。
+    - **rank** (int) - Rank编号。
+    - **rank_size** (int) - Rank总数。
 
-    .. py:method:: generate_group_params(parameters, origin_params)
+    **输入：**
 
-        创建分组权重。
+    - **loss** (Tensor) - 标量Tensor。
+    - **old_grad** (Tuple(Tensor)) - 网络权重提取组成的元组。
+    - **weight** (Tuple(Tensor)) - 网络权重组成的元组。
+    - **weight_clone** (Tuple(Tensor)) - 网络权重的副本。
+    - **(\*inputs)** (Tuple(Tensor)) - 网络的所有输入组成的元组。
 
-        **参数：**
+    **输出：**
 
-        - **parameters** (list) – 训练网络的新权重。
-        - **origin_params** (list) –  训练网络的初始权重。
+    - **loss** (Tensor) - 标量Tensor。
 
 .. automodule:: mindspore.boost
     :members: