mindspore 2.5.0__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.whl

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/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

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

@@ -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/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)
 

mindspore/nn/probability/bijector/gumbel_cdf.py

@@ -33,11 +33,11 @@ class GumbelCDF(Bijector):
         name (str): The name of the Bijector. Default: ``'GumbelCDF'`` .
 
     Note:
-        `scale` must be greater than zero.
-        For `inverse` and `inverse_log_jacobian`, input should be in range of (0, 1).
-        The dtype of `loc` and `scale` must be float.
-        If `loc`, `scale` are passed in as numpy.ndarray or tensor, they have to have
-        the same dtype otherwise an error will be raised.
+        - `scale` must be greater than zero.
+        - For `inverse` and `inverse_log_jacobian`, input should be in range of (0, 1).
+        - The dtype of `loc` and `scale` must be float.
+        - If `loc`, `scale` are passed in as numpy.ndarray or tensor, they have to have
+          the same dtype otherwise an error will be raised.
 
     Raises:
         TypeError: When the dtype of `loc` or `scale` is not float,

mindspore/nn/probability/bijector/invert.py

@@ -25,8 +25,8 @@ class Invert(Bijector):
 
     Args:
         bijector (Bijector): Base Bijector.
-        name (str): The name of the Bijector. Default: ``""`` . When name is set to "", it is actually
-            'Invert' + bijector.name.
+        name (str): The name of the Bijector. Default: ``""`` . When name is set to ``""``, it is actually
+            ``'Invert' + Bijector.name``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/nn/probability/bijector/scalar_affine.py

@@ -26,11 +26,11 @@ class ScalarAffine(Bijector):
     .. math::
         Y = a * X + b
 
-    where a is the scale factor and b is the shift factor.
+    where :math:`a` is the scale factor and :math:`b` is the shift factor.
 
     Args:
-        scale (float, list, numpy.ndarray, Tensor): The scale factor. Default: ``1.0`` .
-        shift (float, list, numpy.ndarray, Tensor): The shift factor. Default: ``0.0`` .
+        scale (float, list, numpy.ndarray, Tensor): The scale factor. :math:`a` in the formula. Default: ``1.0`` .
+        shift (float, list, numpy.ndarray, Tensor): The shift factor. :math:`b` in the formula. Default: ``0.0`` .
         name (str): The name of the bijector. Default: ``'ScalarAffine'`` .
 
     Note:

mindspore/nn/probability/bijector/softplus.py

@@ -29,10 +29,11 @@ class Softplus(Bijector):
     .. math::
         Y = \frac{\log(1 + e ^ {kX})}{k}
 
-    where k is the sharpness factor.
+    where :math:`k` is the sharpness factor.
 
     Args:
-        sharpness (float, list, numpy.ndarray, Tensor): The scale factor. Default: ``1.0`` .
+        sharpness (float, list, numpy.ndarray, Tensor): The scale factor. :math:`k` in the above formula.
+            Default: ``1.0`` .
         name (str): The name of the Bijector. Default: ``'Softplus'`` .
 
     Note:

mindspore/nn/probability/distribution/beta.py

@@ -37,9 +37,9 @@ class Beta(Distribution):
 
     Args:
         concentration1 (int, float, list, numpy.ndarray, Tensor): The concentration1,
-          also know as alpha of the Beta distribution. Default: ``None`` .
+          also know as :math:`alpha` of the Beta distribution. Default: ``None`` .
         concentration0 (int, float, list, numpy.ndarray, Tensor): The concentration0, also know as
-          beta of the Beta distribution. Default: ``None`` .
+          :math:`beta` of the Beta distribution. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Beta'`` .
@@ -51,7 +51,7 @@ class Beta(Distribution):
 
     Raises:
         ValueError: When concentration1 <= 0 or concentration0 >=1.
-        TypeError: When the input `dtype` is not a subclass of float.
+        TypeError: When the input `dtype` is not a float or a subclass of float.
 
     Supported Platforms:
         ``Ascend``

mindspore/nn/probability/distribution/categorical.py

@@ -40,7 +40,7 @@ class Categorical(Distribution):
         probs (Tensor, list, numpy.ndarray): Event probabilities. Default: ``None`` .
         seed (int): The global seed is used in sampling. Global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.int32`` .
-        name (str): The name of the distribution. Default: ``Categorical`` .
+        name (str): The name of the distribution. Default: ``'Categorical'`` .
 
     Note:
         `probs` must have rank at least 1, values are proper probabilities and sum to 1.

mindspore/nn/probability/distribution/cauchy.py

@@ -35,8 +35,10 @@ class Cauchy(Distribution):
     Where :math:`a, b` are loc and scale parameter respectively.
 
     Args:
-        loc (int, float, list, numpy.ndarray, Tensor): The location of the Cauchy distribution. Default: ``None`` .
-        scale (int, float, list, numpy.ndarray, Tensor): The scale of the Cauchy distribution. Default: ``None`` .
+        loc (int, float, list, numpy.ndarray, Tensor): The location of the Cauchy distribution.
+            :math:`a` in the formula. Default: ``None`` .
+        scale (int, float, list, numpy.ndarray, Tensor): The scale of the Cauchy distribution.
+            :math:`b` in the formula. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Cauchy'`` .

mindspore/nn/probability/distribution/exponential.py

@@ -35,15 +35,14 @@ class Exponential(Distribution):
     where :math:`\lambda` is the rate of the distribution.
 
     Args:
-        rate (int, float, list, numpy.ndarray, Tensor): The inverse scale. Default: ``None`` .
-        seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
-        dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
-        name (str): The name of the distribution. Default: ``'Exponential'`` .
+        rate (int, float, list, numpy.ndarray, Tensor, optional): The inverse scale. :math:`\lambda` in the formula. Default: ``None`` .
+        seed (int, optional): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
+        dtype (mindspore.dtype, optional): The type of the event samples. Default: ``mstype.float32`` .
+        name (str, optional): The name of the distribution. Default: ``'Exponential'`` .
 
     Note:
-        `rate` must be strictly greater than 0.
-        `dist_spec_args` is `rate`.
-        `dtype` must be a float type because Exponential distributions are continuous.
+        - `rate` must be strictly greater than 0.
+        - `dtype` must be a float type because Exponential distributions are continuous.
 
     Raises:
         ValueError: When rate <= 0.

mindspore/nn/probability/distribution/gamma.py

@@ -39,9 +39,9 @@ class Gamma(Distribution):
 
     Args:
         concentration (int, float, list, numpy.ndarray, Tensor): The concentration,
-          also know as alpha of the Gamma distribution. Default: ``None`` .
+          also know as :math:`\alpha` of the Gamma distribution. Default: ``None`` .
         rate (int, float, list, numpy.ndarray, Tensor): The rate, also know as
-          beta of the Gamma distribution. Default: ``None`` .
+          :math:`\beta` of the Gamma distribution. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Gamma'`` .

mindspore/nn/probability/distribution/gumbel.py

@@ -37,8 +37,8 @@ class Gumbel(TransformedDistribution):
     Where :math:`a, b` are loc and scale parameter respectively.
 
     Args:
-        loc (int, float, list, numpy.ndarray, Tensor): The location of Gumbel distribution.
-        scale (int, float, list, numpy.ndarray, Tensor): The scale of Gumbel distribution.
+        loc (int, float, list, numpy.ndarray, Tensor): The location of Gumbel distribution. :math:`a` in the formula.
+        scale (int, float, list, numpy.ndarray, Tensor): The scale of Gumbel distribution. :math:`b` in the formula.
         seed (int): the seed used in sampling. The global seed is used if it is None. Default: ``0`` .
         dtype (mindspore.dtype): type of the distribution. Default: ``mstype.float32`` .
         name (str): the name of the distribution. Default: ``'Gumbel'`` .

mindspore/nn/probability/distribution/half_normal.py

@@ -36,9 +36,11 @@ class HalfNormal(Distribution):
     where :math:`\mu, \sigma` are the mean and the standard deviation of the half normal distribution respectively.
 
     Args:
-        mean (Union[int, float, list, numpy.ndarray, Tensor], optional): The mean of the distribution.
+        mean (Union[int, float, list, numpy.ndarray, Tensor], optional):
+            The mean of the distribution. :math:`\mu` in the formula.
             If this arg is ``None`` , then the mean of the distribution will be passed in runtime. Default: ``None`` .
-        sd (Union[int, float, list, numpy.ndarray, Tensor], optional): The standard deviation of the distribution.
+        sd (Union[int, float, list, numpy.ndarray, Tensor], optional):
+            The standard deviation of the distribution. :math:`\sigma` in the formula.
             If this arg is ``None`` , then the sd of the distribution will be passed in runtime. Default: ``None`` .
         seed (int, optional): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype, optional): The type of the event samples. Default: ``mstype.float32`` .
@@ -52,7 +54,7 @@ class HalfNormal(Distribution):
 
     Raises:
         ValueError: When sd <= 0.
-        TypeError: When the input `dtype` is not a subclass of float.
+        TypeError: When the input `dtype` is not a float or a subclass of float.
 
     Supported Platforms:
         ``CPU``

mindspore/nn/probability/distribution/logistic.py

@@ -36,8 +36,10 @@ class Logistic(Distribution):
     where :math:`a, b` are loc and scale parameter respectively.
 
     Args:
-        loc (float, list, numpy.ndarray, Tensor): The location of the Logistic distribution. Default: ``None`` .
-        scale (float, list, numpy.ndarray, Tensor): The scale of the Logistic distribution. Default: ``None`` .
+        loc (float, list, numpy.ndarray, Tensor): The location of the Logistic distribution.
+            :math:`a` in the formula. Default: ``None`` .
+        scale (float, list, numpy.ndarray, Tensor): The scale of the Logistic distribution.
+            :math:`b` in the formula. Default: ``None`` .
         seed (int): The seed used in sampling. The global seed is used if it is None. Default: ``None`` .
         dtype (mindspore.dtype): The type of the event samples. Default: ``mstype.float32`` .
         name (str): The name of the distribution. Default: ``'Logistic'`` .
@@ -49,7 +51,7 @@ class Logistic(Distribution):
 
     Raises:
         ValueError: When scale <= 0.
-        TypeError: When the input `dtype` is not a subclass of float.
+        TypeError: When the input `dtype` is not a float or a subclass of float.
 
     Supported Platforms:
         ``Ascend`` ``GPU``