mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.6.0rc1__cp311-cp311-win_amd64.whl

mindspore/nn/optim/adam.py

@@ -566,7 +566,7 @@ class Adam(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Default: ``1e-3`` .
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional): Default: ``1e-3`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -582,23 +582,26 @@ class Adam(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of current step.
 
-        beta1 (float): The exponential decay rate for the 1st moment estimations. Should be in range (0.0, 1.0).
+        beta1 (float, optional): The exponential decay rate for the 1st moment estimations.
+                       Should be in range (0.0, 1.0).
                        Default: ``0.9`` .
-        beta2 (float): The exponential decay rate for the 2nd moment estimations. Should be in range (0.0, 1.0).
+        beta2 (float, optional): The exponential decay rate for the 2nd moment estimations.
+                       Should be in range (0.0, 1.0).
                        Default: ``0.999`` .
-        eps (float): Term added to the denominator to improve numerical stability. Should be greater than 0.
+        eps (float, optional): Term added to the denominator to improve numerical stability. Should be greater than 0.
                      Default: ``1e-8`` .
-        use_locking (bool): Whether to enable a lock to protect the updating process of variable tensors.
+        use_locking (bool, optional): Whether to enable a lock to protect the updating process of variable tensors.
             If ``true`` , updates of the `w`, `m`, and `v` tensors will be protected by a lock.
             If ``false`` , the result is unpredictable. Default: ``False`` .
-        use_nesterov (bool): Whether to use Nesterov Accelerated Gradient (NAG) algorithm to update the gradients.
+        use_nesterov (bool, optional): Whether to use Nesterov Accelerated Gradient (NAG) algorithm
+            to update the gradients.
             If ``true`` , update the gradients using NAG.
             If ``false`` , update the gradients without using NAG. Default: ``False`` .
-        use_amsgrad (bool): Whether to use Amsgrad algorithm to update the gradients.
+        use_amsgrad (bool, optional): Whether to use Amsgrad algorithm to update the gradients.
             If ``true`` , update the gradients using Amsgrad.
             If ``false`` , update the gradients without using Amsgrad. Default: ``False`` .
 
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 
@@ -607,11 +610,12 @@ class Adam(Optimizer):
             - Cell: Weight decay is dynamic. During training, the optimizer calls the instance of
               the Cell with step as the input to get the weight decay value of current step.
 
-        loss_scale (float): A floating point value for the loss scale. Should be greater than 0. In general, use the
+        loss_scale (float, optional): A floating point value for the loss scale.
+            Should be greater than 0. In general, use the
             default value. Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to False, then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.
-            Default: 1.0.
+            Default: ``1.0``.
 
         kwargs:
 
@@ -633,7 +637,7 @@ class Adam(Optimizer):
     Raises:
         KeyError: If kwargs got keys other than 'use_lazy' or 'use_offload'.
         TypeError: If `learning_rate` is not one of int, float, Tensor, Iterable, LearningRateSchedule.
-        TypeError: If element of `parameters` is neither Parameter nor dict.
+        TypeError: If element of `params` is neither Parameter nor dict.
         TypeError: If `beta1`, `beta2`, `eps` or `loss_scale` is not a float.
         TypeError: If `weight_decay` is neither float nor int.
         TypeError: If `use_locking`, `use_nesterov`, `use_amsgrad`, `use_lazy` or `use_offload` is not a bool.
@@ -1024,7 +1028,7 @@ class AdamWeightDecay(Optimizer):
         self.fused_opt = P.AdamWeightDecay()
         self.use_fused_opt = True
 
-    @jit
+    @jit(backend="ms_backend")
     def construct(self, gradients):
         gradients = self.flatten_gradients(gradients)
         weight_decay = self.get_weight_decay()
@@ -1244,7 +1248,7 @@ class AdamOffload(Optimizer):
         self.opt = P.AdamNoUpdateParam(use_locking, use_nesterov)
         self.opt.set_device("CPU")
 
-    @jit
+    @jit(backend="ms_backend")
     def construct(self, gradients):
         params = self._parameters
         moment1 = self.moment1

mindspore/nn/optim/adamax.py

@@ -118,12 +118,12 @@ class AdaMax(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of current step.
 
-        beta1 (float): The exponential decay rate for the 1st moment estimations. Should be in range (0.0, 1.0).
-                       Default: ``0.9`` .
-        beta2 (float): The exponential decay rate for the 2nd moment estimations. Should be in range (0.0, 1.0).
-                       Default: ``0.999`` .
-        eps (float): Term added to the denominator to improve numerical stability. Should be greater than 0.
-                     Default: ``1e-08`` .
+        beta1 (float, optional): The exponential decay rate for the 1st moment estimations.
+            Should be in range (0.0, 1.0). Default: ``0.9`` .
+        beta2 (float, optional): The exponential decay rate for the 2nd moment estimations.
+            Should be in range (0.0, 1.0). Default: ``0.999`` .
+        eps (float, optional): Term added to the denominator to improve numerical stability. Should be greater than 0.
+            Default: ``1e-08`` .
 
         weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
 
@@ -134,7 +134,8 @@ class AdaMax(Optimizer):
             - Cell: Weight decay is dynamic. During training, the optimizer calls the instance of
               the Cell with step as the input to get the weight decay value of current step.
 
-        loss_scale (float): A floating point value for the loss scale. Should be greater than 0. In general, use the
+        loss_scale (float, optional): A floating point value for the loss scale. Should be greater than 0.
+            In general, use the
             default value. Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to ``False`` , then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.

mindspore/nn/optim/adasum.py

@@ -420,17 +420,17 @@ class AdaSumByGradWrapCell(Cell):
     and the subscripts represent different devices in the data-parallel dimension.
 
     Note:
-        When using AdaSum, the number of traning cards needs to be a power of 2 and at least 16 cards are required.
-        Currently, the optimizer sharding and pipeline parallel is not supported when using AdaSum.
-        It is recommended to using AdaSumByGradWrapCell in semi auto parallel/auto parallel mode. In data parallel
-        mode, we recommend to using mindspore.boost to applying AdaSum.
+        - It is recommended to using AdaSumByGradWrapCell in semi auto parallel/auto parallel mode. In data parallel
+          mode, we recommend to using mindspore.boost to applying AdaSum.
+        - When using AdaSum, the number of traning cards needs to be a power of 2 and at least 16 cards are required.
+          Currently, the optimizer sharding and pipeline parallel is not supported when using AdaSum.
 
     Args:
         optimizer (Union[Cell]): Optimizer for updating the weights. The construct function of the optimizer
             requires only one input.
 
     Inputs:
-        - **grads** (Tuple(Tensor)) - Tuple of gradients, same with the input of passed optimizer.
+        - **grads** (Tuple[Tensor]) - Tuple of gradients, same with the input of passed optimizer.
 
     Raises:
         RuntimeError: If `parallel_mode` uses `stand_alone` mode, AdaSum only supports use in distributed scenarios.

mindspore/nn/optim/asgd.py

@@ -180,7 +180,7 @@ class ASGD(Optimizer):
         self.cast = P.Cast()
         self.squeeze = P.Squeeze()
 
-    @jit
+    @jit(backend="ms_backend")
     def construct(self, gradients):
         gradients = self.flatten_gradients(gradients)
         gradients = self.decay_weight(gradients)

mindspore/nn/optim/ftrl.py

@@ -228,21 +228,23 @@ class FTRL(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        initial_accum (float): The starting value for accumulators `m`, must be zero or positive values.
+        initial_accum (float, optional): The starting value for accumulators `m`, must be zero or positive values.
             Default: ``0.1`` .
-        learning_rate (float): The learning rate value, must be zero or positive, dynamic learning rate is currently
-            not supported. Default: ``0.001`` .
-        lr_power (float): Learning rate power controls how the learning rate decreases during training, must be less
+        learning_rate (float, optional): The learning rate value, must be zero or positive, dynamic learning rate
+            is currently not supported. Default: ``0.001`` .
+        lr_power (float, optional): Learning rate power controls how the learning rate decreases during training,
+            must be less
             than or equal to zero. Use fixed learning rate if lr_power is zero. Default: ``-0.5`` .
-        l1 (float): l1 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
-        l2 (float): l2 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
-        use_locking (bool): If true, use locks for updating operation. Default: ``False`` .
-        loss_scale (float): Value for the loss scale. It must be greater than 0.0. In general, use the default value.
+        l1 (float, optional): l1 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
+        l2 (float, optional): l2 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
+        use_locking (bool, optional): If true, use locks for updating operation. Default: ``False`` .
+        loss_scale (float, optional): Value for the loss scale. It must be greater than 0.0. In general,
+            use the default value.
             Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to ``False`` , then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.
             Default: ``1.0`` .
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 

mindspore/nn/optim/lamb.py

@@ -265,7 +265,7 @@ class Lamb(Optimizer):
         self.moments2 = self.params.clone(prefix="lamb_v", init='zeros')
         self.device_ascend = context.get_context("device_target") == "Ascend"
 
-    @jit
+    @jit(backend="ms_backend")
     def construct(self, gradients):
         weight_decay = self.get_weight_decay()
         lr = self.get_lr()

mindspore/nn/optim/lars.py

@@ -82,7 +82,7 @@ class LARS(Optimizer):
             &\hline \\[-1.ex]
         \end{array}
 
-    :math:`w` represents the network parameters, :math:`g` represents `gradients`,
+    :math:`w` represents the network's params, :math:`g` represents `gradients`,
     :math:`t` represents the current step, :math:`\lambda` represents `weight_decay` in `optimizer`,
     :math:`\gamma` represents `learning_rate` in `optimizer`, :math:`\eta` represents `coefficient`.
 
@@ -98,9 +98,6 @@ class LARS(Optimizer):
         - **gradients** (tuple[Tensor]) - The gradients of `params` in the optimizer, the shape is the
           as same as the `params` in the optimizer.
 
-    Outputs:
-        Union[Tensor[bool], tuple[Parameter]], it depends on the output of `optimizer`.
-
     Supported Platforms:
         ``Ascend``
 

mindspore/nn/optim/lazyadam.py

@@ -321,7 +321,7 @@ class LazyAdam(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Default: ``1e-3`` .
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional): Default: ``1e-3`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -337,20 +337,21 @@ class LazyAdam(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of current step.
 
-        beta1 (float): The exponential decay rate for the 1st moment estimations. Should be in range (0.0, 1.0).
-                       Default: ``0.9`` .
-        beta2 (float): The exponential decay rate for the 2nd moment estimations. Should be in range (0.0, 1.0).
-                       Default: ``0.999`` .
-        eps (float): Term added to the denominator to improve numerical stability. Should be greater than 0.
+        beta1 (float, optional): The exponential decay rate for the 1st moment estimations.
+            Should be in range (0.0, 1.0). Default: ``0.9`` .
+        beta2 (float, optional): The exponential decay rate for the 2nd moment estimations.
+            Should be in range (0.0, 1.0). Default: ``0.999`` .
+        eps (float, optional): Term added to the denominator to improve numerical stability. Should be greater than 0.
                      Default: ``1e-8`` .
-        use_locking (bool): Whether to enable a lock to protect the updating process of variable tensors.
+        use_locking (bool, optional): Whether to enable a lock to protect the updating process of variable tensors.
             If ``true`` , updates of the `w`, `m`, and `v` tensors will be protected by a lock.
             If ``false`` , the result is unpredictable. Default: ``False`` .
-        use_nesterov (bool): Whether to use Nesterov Accelerated Gradient (NAG) algorithm to update the gradients.
+        use_nesterov (bool, optional): Whether to use Nesterov Accelerated Gradient (NAG) algorithm to
+            update the gradients.
             If ``true`` , update the gradients using NAG.
             If ``false`` , update the gradients without using NAG. Default: ``False`` .
 
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 
@@ -359,7 +360,8 @@ class LazyAdam(Optimizer):
             - Cell: Weight decay is dynamic. During training, the optimizer calls the instance of
               the Cell with step as the input to get the weight decay value of current step.
 
-        loss_scale (float): A floating point value for the loss scale. Should be equal to or greater than 1. In general,
+        loss_scale (float, optional): A floating point value for the loss scale. Should be equal to or greater than 1.
+            In general,
             use the default value. Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update`
             in `FixedLossScaleManager` is set to ``False`` , then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.

mindspore/nn/optim/momentum.py

@@ -103,7 +103,7 @@ class Momentum(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]):
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional):
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -119,10 +119,10 @@ class Momentum(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of current step.
 
-        momentum (float): Hyperparameter of type float, means momentum for the moving average.
+        momentum (float, optional): Hyperparameter of type float, means momentum for the moving average.
             It must be at least 0.0.
 
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 
@@ -131,12 +131,13 @@ class Momentum(Optimizer):
             - Cell: Weight decay is dynamic. During training, the optimizer calls the instance of
               the Cell with step as the input to get the weight decay value of current step.
 
-        loss_scale (float): A floating point value for the loss scale. It must be greater than 0.0. In general, use the
+        loss_scale (float, optional): A floating point value for the loss scale. It must be greater than 0.0.
+            In general, use the
             default value. Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to ``False`` , then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.
             Default: ``1.0`` .
-        use_nesterov (bool): Enable Nesterov momentum. Default: ``False`` .
+        use_nesterov (bool, optional): Enable Nesterov momentum. Default: ``False`` .
 
     Inputs:
         - **gradients** (tuple[Tensor]) - The gradients of `params`, the shape is the same as `params`.
@@ -199,7 +200,7 @@ class Momentum(Optimizer):
         self._get_distributed_optimizer_list("momentum", use_nesterov=self.use_nesterov)
         self.use_dist_optimizer = self._use_distibuted_optimizer()
 
-    @jit
+    @jit(backend="ms_backend")
     def construct(self, gradients):
         params = self.params
         moments = self.moments

mindspore/nn/optim/optimizer.py

@@ -122,10 +122,10 @@ class Optimizer(Cell):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        weight_decay (Union[float, int]): An int or a floating point value for the weight decay.
+        weight_decay (Union[float, int], optional): An int or a floating point value for the weight decay.
             It must be equal to or greater than 0.
             If the type of `weight_decay` input is int, it will be converted to float. Default: ``0.0`` .
-        loss_scale (float): A floating point value for the loss scale. It must be greater than 0. If the
+        loss_scale (float, optional): A floating point value for the loss scale. It must be greater than 0. If the
             type of `loss_scale` input is int, it will be converted to float. In general, use the default value. Only
             when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to ``False`` , this value needs to be the same as the `loss_scale` in
@@ -848,7 +848,7 @@ class Optimizer(Cell):
             optim_result(bool): The results of updating parameters. This input is used to ensure that the parameters are
               updated before they are broadcast.
         Returns:
-             bool, the status flag.
+             The broadcast parameters.
         """
         # If rank_id is 0, 1, 2, 3, there are param0 ~ param7,
         # then the value is[(param0, param4), (param1, param5), (param2, param6), (param3, param7)]

mindspore/nn/optim/proximal_ada_grad.py

@@ -83,8 +83,8 @@ class ProximalAdagrad(Optimizer):
 
     Args:
         params (Union[list[Parameter], list[dict]]): Must be list of `Parameter` or list of `dict`. When the
-            `params` is a list of `dict`, the string "params", "lr", "weight_decay", "grad_centralization" and
-            "order_params" are the keys can be parsed.
+            `params` is a list of `dict`, the string `"params"`, `"lr"`, `"weight_decay"`, `"grad_centralization"` and
+            `"order_params"` are the keys can be parsed.
 
             - params: Required. Parameters in current group. The value must be a list of `Parameter`.
 
@@ -108,8 +108,9 @@ class ProximalAdagrad(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        accum (float): The starting value for accumulators `accum`, must be zero or positive values. Default: ``0.1`` .
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Default: ``0.001`` .
+        accum (float, optional): The starting value for accumulators `accum`, must be zero or positive values.
+            Default: ``0.1`` .
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional): Default: ``0.001`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -125,15 +126,16 @@ class ProximalAdagrad(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of the current step.
 
-        l1 (float): l1 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
-        l2 (float): l2 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
-        use_locking (bool): If true, use locks for updating operation. Default: ``False`` .
-        loss_scale (float): Value for the loss scale. It must be greater than 0.0. In general, use the default value.
+        l1 (float, optional): l1 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
+        l2 (float, optional): l2 regularization strength, must be greater than or equal to zero. Default: ``0.0`` .
+        use_locking (bool, optional): If ``True``, use locks for updating operation. Default: ``False`` .
+        loss_scale (float, optional): Value for the loss scale. It must be greater than 0.0. In general,
+            use the default value.
             Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to ``False`` , then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.
             Default: ``1.0`` .
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 
@@ -199,7 +201,7 @@ class ProximalAdagrad(Optimizer):
         self.opt = P.ApplyProximalAdagrad(use_locking=use_locking)
         self.sparse_opt = P.SparseApplyProximalAdagrad(use_locking=use_locking)
 
-    @jit
+    @jit(backend="ms_backend")
     def construct(self, grads):
         params = self._parameters
         accum = self.accum

mindspore/nn/optim/rmsprop.py

@@ -92,9 +92,9 @@ class RMSProp(Optimizer):
     :math:`t` represents the current step.
 
     Note:
-        If parameters are not grouped, the `weight_decay` in optimizer will be applied on the network parameters without
-        'beta' or 'gamma' in their names. Users can group parameters to change the strategy of decaying weight. When
-        parameters are grouped, each group can set `weight_decay`. If not, the `weight_decay` in optimizer will be
+        If parameters are not grouped, the `weight_decay` in optimizer will be applied on the network parameters
+        without 'beta' or 'gamma' in their names. Users can group parameters to change the strategy of decaying weight.
+        When parameters are grouped, each group can set `weight_decay`. If not, the `weight_decay` in optimizer will be
         applied.
 
     Args:
@@ -124,7 +124,7 @@ class RMSProp(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Default: ``0.1`` .
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional): Default: ``0.1`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -140,21 +140,22 @@ class RMSProp(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of the current step.
 
-        decay (float): Decay rate. Should be equal to or greater than 0. Default: ``0.9`` .
-        momentum (float): Hyperparameter of type float, means momentum for the moving average. Should be equal to or
-                          greater than 0. Default: ``0.0`` .
-        epsilon (float): Term added to the denominator to improve numerical stability. Should be greater than
+        decay (float, optional): Decay rate. Should be equal to or greater than 0. Default: ``0.9`` .
+        momentum (float, optional): Hyperparameter of type float, means momentum for the moving average.
+            Should be equal to or greater than 0. Default: ``0.0`` .
+        epsilon (float, optional): Term added to the denominator to improve numerical stability. Should be greater than
                          0. Default: ``1e-10`` .
-        use_locking (bool):  Whether to enable a lock to protect the updating process of variable tensors.
+        use_locking (bool, optional):  Whether to enable a lock to protect the updating process of variable tensors.
             Default: ``False`` .
-        centered (bool): If True, gradients are normalized by the estimated variance of the gradient.
+        centered (bool, optional): If True, gradients are normalized by the estimated variance of the gradient.
             Default: ``False`` .
-        loss_scale (float): A floating point value for the loss scale. Should be greater than 0. In general, use the
+        loss_scale (float, optional): A floating point value for the loss scale. Should be greater than 0. In general,
+            use the
             default value. Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to ``False`` , then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.
             Default: ``1.0`` .
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 

mindspore/nn/optim/rprop.py

@@ -44,8 +44,8 @@ class Rprop(Optimizer):
             &\hspace{15mm} w_{t} \leftarrow w_{t-1}- \Delta_{t} \mathrm{sign}(g_t)                 \\
         \end{gather*}
 
-    :math:`\Delta_{min/max}` represents the min/max step size, :math:`\eta_{+/-}` represents the factors of
-    etaminus and etaplus, :math:`g` represents `gradients`, :math:`w` represents `parameters`.
+    :math:`g` represents `gradients`, :math:`w` represents `parameters`, :math:`\Delta_{min/max}` represents the
+    min/max step size, :math:`\eta_{+/-}` represents the factors of etaminus and etaplus.
 
     Note:
         If parameters are not grouped, the `weight_decay` in optimizer will be applied on the parameters without 'beta'
@@ -58,8 +58,8 @@ class Rprop(Optimizer):
 
     Args:
         params (Union[list[Parameter], list[dict]]): Must be list of `Parameter` or list of `dict`. When the
-            `parameters` is a list of `dict`, the "params", "lr", "weight_decay", "grad_centralization" and
-            "order_params" are the keys can be parsed.
+            `parameters` is a list of `dict`, the `"params"`, `"lr"`, `"weight_decay"`, `"grad_centralization"` and
+            `"order_params"` are the keys can be parsed.
 
             - params: Required. Parameters in current group. The value must be a list of `Parameter`.
 
@@ -83,7 +83,8 @@ class Rprop(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Learning_rate. Default: ``0.1`` .
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional): Learning_rate.
+            Default: ``0.1`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -99,11 +100,12 @@ class Rprop(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of current step.
 
-        etas (tuple[float, float]): The factor of multiplicative increasing or
+        etas (tuple[float, float], optional): The factor of multiplicative increasing or
             descreasing(etaminus, etaplus). Default: ``(0.5, 1.2)`` .
-        step_sizes(tuple[float, float]): The allowed minimal and maximal step size(min_step_sizes, max_step_size).
+        step_sizes(tuple[float, float], optional): The allowed minimal and maximal
+            step size(min_step_sizes, max_step_size).
             Default: ``(1e-6, 50.)`` .
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
+        weight_decay (Union[float, int, Cell], optional): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 
@@ -199,7 +201,7 @@ class Rprop(Optimizer):
         self.select = P.Select()
         self.ones_like = P.OnesLike()
 
-    @jit
+    @jit(backend="ms_backend")
     def construct(self, gradients):
         gradients = self.flatten_gradients(gradients)
         gradients = self.decay_weight(gradients)

mindspore/nn/optim/sgd.py

@@ -90,7 +90,7 @@ class SGD(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Default: ``0.1`` .
+        learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule], optional): Default: ``0.1`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -106,12 +106,15 @@ class SGD(Optimizer):
               <https://www.mindspore.cn/docs/en/master/api_python/mindspore.nn.html#learningrateschedule-class>`_
               with step as the input to get the learning rate of current step.
 
-        momentum (float): A floating point value the momentum. must be at least 0.0. Default: ``0.0`` .
-        dampening (float): A floating point value of dampening for momentum. must be at least 0.0. Default: ``0.0`` .
-        weight_decay (float): Weight decay (L2 penalty). It must be equal to or greater than 0. Default: ``0.0`` .
-        nesterov (bool): Enables the Nesterov momentum. If use nesterov, momentum must be positive,
+        momentum (float, optional): A floating point value the momentum. must be at least 0.0. Default: ``0.0`` .
+        dampening (float, optional): A floating point value of dampening for momentum. must be at least 0.0.
+            Default: ``0.0`` .
+        weight_decay (float, optional): Weight decay (L2 penalty). It must be equal to or greater than 0.
+            Default: ``0.0`` .
+        nesterov (bool, optional): Enables the Nesterov momentum. If use nesterov, momentum must be positive,
                          and dampening must be equal to 0.0. Default: ``False`` .
-        loss_scale (float): A floating point value for the loss scale, which must be larger than 0.0. In general, use
+        loss_scale (float, optional): A floating point value for the loss scale, which must be larger than 0.0.
+            In general, use
             the default value. Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to ``False`` , then this value needs to be the same as the `loss_scale` in
             `FixedLossScaleManager`. Refer to class :class:`mindspore.amp.FixedLossScaleManager` for more details.

mindspore/nn/optim/tft_wrapper.py

@@ -67,14 +67,16 @@ class OptTFTWrapper(Optimizer):
             raise TypeError(f"For 'OptTFTWrapper', the argument 'opt' must be Optimizer type, " f"but got {type(opt)}.")
         super(OptTFTWrapper, self).__init__(opt.learning_rate, opt._parameters) # pylint: disable=W0212
         tft_env = os.getenv("MS_ENABLE_TFT", "")
-        if ("TTP:1" not in tft_env) and ("UCE:1" not in tft_env):
-            raise ValueError("MindIO TFT regitster need custom switch on[MS_ENABLE_TFT='{TTP:1,UCE:1}']!")
+        if ("TTP:1" not in tft_env) and ("UCE:1" not in tft_env) and ("ARF:1" not in tft_env):
+            raise ValueError("MindIO TFT regitster need custom switch on[MS_ENABLE_TFT='{TTP:1,UCE:1,ARF:1}']!")
         mode = context.get_context("mode")
         device_target = context.get_context("device_target")
         if device_target != "Ascend" or mode != context.GRAPH_MODE:
             raise ValueError("MindIO adataper only support on Ascend device with GRAPH Mode!")
         self.opt = opt
         self.report = TensorReport()
+        self.report_end = TensorReport()
+        self.report_end.add_prim_attr("side_effect_mem", True).add_prim_attr("optimizer_end", True)
         self.depend = ops.Depend()
         self.allreduce_sum = ops.AllReduce()
         self.allreduce_sum.add_prim_attr("tft_report_before", True)
@@ -121,4 +123,5 @@ class OptTFTWrapper(Optimizer):
 
         grads = self.depend(gradients, self.report("tft_report", self.tft_g_one_flag))
         opt_ret = self.opt(grads)
+        self.report_end("tft_report", self.tft_g_one_flag)
         return opt_ret

mindspore/nn/optim/thor.py

@@ -21,6 +21,7 @@ from mindspore.ops import functional as F, composite as C, operations as P
 from mindspore.common.initializer import initializer
 from mindspore.common.parameter import Parameter, ParameterTuple
 from mindspore.common.tensor import Tensor
+from mindspore.common import set_recursion_limit
 import mindspore.ops as ops
 import mindspore.nn as nn
 import mindspore.common.dtype as mstype
@@ -355,7 +356,7 @@ def thor(net, learning_rate, damping, momentum, weight_decay=0.0, loss_scale=1.0
         ...                                                 amp_level="O2", keep_batchnorm_fp32=False)
 
     """
-    context.set_context(max_call_depth=10000)
+    set_recursion_limit(10000)
     ConvertNetUtils().convert_to_thor_net(net)
     if context.get_context("device_target") == "Ascend":
         return ThorAscend(net, learning_rate, damping, momentum, weight_decay, loss_scale, batch_size, decay_filter,

mindspore/nn/probability/bijector/bijector.py

@@ -41,15 +41,20 @@ class Bijector(Cell):
         param (dict): The parameters used to initialize the Bijector. Default: ``None`` .
 
     Note:
-        `dtype` of bijector represents the type of the distributions that the bijector could operate on.
-        When `dtype` is None, there is no enforcement on the type of input value except that the input value
-        has to be float type. During initialization, when `dtype` is None, there is no enforcement on the dtype
-        of the parameters. All parameters should have the same float type, otherwise a TypeError will be raised.
-        Specifically, the parameter type will follow the dtype of the input value, i.e. parameters of the bijector
-        will be casted into the same type as input value when `dtype` is None.
-        When `dtype` is specified, it is forcing the parameters and input value to be the same dtype as `dtype`.
-        When the type of parameters or the type of the input value is not the same as `dtype`, a TypeError will be
-        raised. Only subtype of mindspore.float_type can be used to specify bijector's `dtype`.
+        - `dtype` of bijector represents the type of the distributions that the bijector could operate on.
+        - When `dtype` is None, there is no enforcement on the type of input value except that the input value
+          has to be float type. During initialization, when `dtype` is None, there is no enforcement on the dtype
+          of the parameters. All parameters should have the same float type, otherwise a TypeError will be raised.
+
+          Specifically, the parameter type will follow the dtype of the input value.
+
+          - Parameters of the bijector will be casted into the same type as input value when `dtype` is None.
+
+          - When `dtype` is specified, it is forcing the parameters and input value to be the same dtype as `dtype`.
+            When the type of parameters or the type of the input value is not the same as `dtype`, a TypeError will be
+            raised.
+
+        - Only subtype of mindspore.float_type can be used to specify bijector's `dtype`.
 
     Supported Platforms:
         ``Ascend`` ``GPU``
@@ -226,7 +231,8 @@ class Bijector(Cell):
 
     def cast_param_by_value(self, value, para):
         """
-        Cast the parameter(s) of the bijector to be the same type of input_value.
+        Converts the data type of `para` in the input to the same type as `value`.
+        Typically used by subclasses of Bijector to convert data types of their own parameters.
 
         Args:
             value (Tensor): input value.
@@ -276,7 +282,7 @@ class Bijector(Cell):
             **kwargs (dict): the dictionary of keyword arguments forwarded to subclasses.
 
         Returns:
-            Tensor, the value of logarithm of the derivative of the forward transformation.
+            Tensor, outputs the value of a random variable after mapping.
         """
         return self._forward_log_jacobian(value, *args, **kwargs)