mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/nn/optim/rprop.py

@@ -83,7 +83,7 @@ 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]): Learning_rate. Default: ``0.1`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -98,10 +98,10 @@ class Rprop(Optimizer):
               LearningRateSchedule with step as the input to get the learning rate of current step.
 
         etas (tuple[float, float]): The factor of multiplicative increasing or
-            descreasing(etaminus, etaplus). Default: (0.5, 1.2).
+            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).
-            Default: (1e-6, 50.).
-        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: 0.0.
+            Default: ``(1e-6, 50.)`` .
+        weight_decay (Union[float, int, Cell]): Weight decay (L2 penalty). Default: ``0.0`` .
 
             - float: The fixed weight decay value. Must be equal to or greater than 0.
 
@@ -134,7 +134,9 @@ class Rprop(Optimizer):
         >>> import mindspore as ms
         >>> from mindspore import nn
         >>>
-        >>> net = Net()
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
         >>> #1) All parameters use the same learning rate and weight decay
         >>> optim = nn.Rprop(params=net.trainable_params())
         >>>
@@ -152,7 +154,7 @@ class Rprop(Optimizer):
         >>> # The final parameters order in which the optimizer will be followed is the value of 'order_params'.
         >>>
         >>> loss = nn.SoftmaxCrossEntropyWithLogits()
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = ms.train.Model(net, loss_fn=loss, optimizer=optim)
     """
 
     @opt_init_args_register
@@ -187,8 +189,8 @@ class Rprop(Optimizer):
         self.prev = self._parameters.clone(prefix="prev", init='zeros')
         self.step_size = self._parameters.clone(prefix="step_size", init='zeros')
 
-        self.fill = P.Fill()
         self.sign = P.Sign()
+        self.fill = P.FillV2()
         self.assign = P.Assign()
         self.assignadd = P.AssignAdd()
         self.cast = P.Cast()
@@ -202,8 +204,7 @@ class Rprop(Optimizer):
         gradients = self.gradients_centralization(gradients)
         gradients = self.scale_grad(gradients)
         lrs = self.get_lr()
-        if not self._is_dynamic_lr_or_weight_decay():
-            self.assignadd(self.global_step, self.global_step_increase_tensor)
+        self.assignadd(self.global_step, self.global_step_increase_tensor)
         success = True
 
         for index, (grad, param, prev, step_size) in enumerate(zip(gradients, self._parameters,
@@ -219,14 +220,26 @@ class Rprop(Optimizer):
             param_fp32 = self.cast(param, mstype.float32)
 
             sign = self.sign(gradient_fp32 * prev)
-            sign = self.select(sign > 0, self.fill(mstype.float32, sign.shape, self.etaplus), sign)
-            sign = self.select(sign < 0, self.fill(mstype.float32, sign.shape, self.etaminus), sign)
-            sign = self.select(sign == 0, self.fill(mstype.float32, sign.shape, 1.), sign)
-
-            step_size_fp32 = ops.clip_by_value(step_size_fp32 * sign, self.step_size_min, self.step_size_max)
-
-            gradient_update = self.select(sign == self.etaminus, self.fill(mstype.float32, sign.shape, 0.),
-                                          gradient_fp32)
+            sign = self.select(
+                sign > 0,
+                self.fill(sign.shape, self.cast(self.etaplus, mstype.float32)),
+                sign)
+            sign = self.select(
+                sign < 0,
+                self.fill(sign.shape, self.cast(self.etaminus,
+                                                mstype.float32)), sign)
+            sign = self.select(
+                sign == 0, self.fill(sign.shape,
+                                     self.cast(1., mstype.float32)), sign)
+
+            step_size_fp32 = ops.clip_by_value(step_size_fp32 * sign,
+                                               self.step_size_min,
+                                               self.step_size_max)
+
+            gradient_update = self.select(
+                sign == self.etaminus,
+                self.fill(sign.shape, self.cast(0., mstype.float32)),
+                gradient_fp32)
             next_param = param_fp32 - self.sign(gradient_update) * step_size_fp32
 
             self.assign(param, self.cast(next_param, param.dtype))

mindspore/nn/optim/sgd.py

@@ -44,17 +44,17 @@ class SGD(Optimizer):
     momentum in deep learning <http://proceedings.mlr.press/v28/sutskever13.html>`_.
 
     .. math::
-            v_{t+1} = u \ast v_{t} + gradient \ast (1-dampening)
+        v_{t+1} = u \ast v_{t} + gradient \ast (1-dampening)
 
     If nesterov is True:
 
     .. math::
-            p_{t+1} = p_{t} - lr \ast (gradient + u \ast v_{t+1})
+        p_{t+1} = p_{t} - lr \ast (gradient + u \ast v_{t+1})
 
     If nesterov is False:
 
     .. math::
-            p_{t+1} = p_{t} - lr \ast v_{t+1}
+        p_{t+1} = p_{t} - lr \ast v_{t+1}
 
     To be noticed, for the first step, :math:`v_{t+1} = gradient`.
 
@@ -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]): Default: ``0.1`` .
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
 
@@ -104,22 +104,22 @@ class SGD(Optimizer):
             - LearningRateSchedule: Learning rate is dynamic. During training, the optimizer calls the instance of
               LearningRateSchedule 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.
+        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,
-                         and dampening must be equal to 0.0. Default: False.
+                         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
             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` 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`` .
 
     Inputs:
         - **gradients** (tuple[Tensor]) - The gradients of `params`, the shape is the same as `params`.
 
     Outputs:
-        Tensor[bool], the value is True.
+        Tensor[bool], the value is ``True`` .
 
     Raises:
         ValueError: If the momentum, dampening or weight_decay value is less than 0.0.
@@ -131,7 +131,9 @@ class SGD(Optimizer):
         >>> import mindspore as ms
         >>> from mindspore import nn
         >>>
-        >>> net = Net()
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
         >>> #1) All parameters use the same learning rate and weight decay
         >>> optim = nn.SGD(params=net.trainable_params())
         >>>
@@ -149,7 +151,7 @@ class SGD(Optimizer):
         >>> # The final parameters order in which the optimizer will be followed is the value of 'order_params'.
         >>>
         >>> loss = nn.SoftmaxCrossEntropyWithLogits()
-        >>> model = ms.Model(net, loss_fn=loss, optimizer=optim)
+        >>> model = ms.train.Model(net, loss_fn=loss, optimizer=optim)
     """
 
     @opt_init_args_register
@@ -161,29 +163,29 @@ class SGD(Optimizer):
         if isinstance(momentum, int):
             momentum = float(momentum)
         if not isinstance(momentum, float):
-            raise TypeError("For 'SGD', the argument 'momentum' must be float type, "
-                            "but got {}.".format(type(momentum)))
+            raise TypeError(f"For 'SGD', the argument 'momentum' must be float type, "
+                            f"but got {type(momentum)}.")
 
         if isinstance(momentum, float) and momentum < 0.0:
-            raise ValueError("For 'SGD', the argument 'momentum' must be at least 0.0, "
-                             "but got {}.".format(momentum))
+            raise ValueError(f"For 'SGD', the argument 'momentum' must be at least 0.0, "
+                             f"but got {momentum}.")
 
         if isinstance(dampening, int):
             dampening = float(dampening)
         if not isinstance(dampening, float):
-            raise TypeError("For 'SGD', the argument 'dampening' must be float type, "
-                            "but got {}.".format(type(dampening)))
+            raise TypeError(f"For 'SGD', the argument 'dampening' must be float type, "
+                            f"but got {type(dampening)}.")
 
         if dampening < 0.0:
-            raise ValueError("For 'SGD', the argument 'dampening' must be at least 0.0, "
-                             "but got 'dampening' {}".format(dampening))
+            raise ValueError(f"For 'SGD', the argument 'dampening' must be at least 0.0, "
+                             f"but got 'dampening' {dampening}")
         self.dampening = dampening
 
         validator.check_value_type("nesterov", nesterov, [bool], self.cls_name)
 
         if nesterov and (momentum <= 0.0 or dampening != 0.0):
-            raise ValueError("For 'SGD', if 'nesterov' is true, 'momentum' must be > 0.0 and 'dampening' must "
-                             "equal to 0.0, but got 'momentum' {}, 'dampening' {}".format(momentum, dampening))
+            raise ValueError(f"For 'SGD', if 'nesterov' is true, 'momentum' must be > 0.0 and 'dampening' must "
+                             f"equal to 0.0, but got 'momentum' {momentum}, 'dampening' {dampening}.")
         self.nesterov = nesterov
 
         if self.dynamic_weight_decay:
@@ -196,9 +198,23 @@ class SGD(Optimizer):
             self.opt = tuple([P.SGD(dampening, float(weight_decay), nesterov)] * len(self._parameters))
 
         self.momentum = Parameter(Tensor(momentum, mstype.float32), name="momentum")
+
+        if not momentum > 0.0:
+            enable_cache_param_list = []
+            for param in self._parameters:
+                if param.cache_enable:
+                    enable_cache_param_list.append(param)
+                    param.cache_enable = False
+
         self.accum = self._parameters.clone(prefix="accum", init='zeros')
         self.stat = self._parameters.clone(prefix="stat", init='ones')
 
+
+        if not momentum > 0.0:
+            for param in enable_cache_param_list:
+                param.cache_enable = True
+
+
     @jit
     def construct(self, gradients):
         params = self._parameters
@@ -208,6 +224,7 @@ class SGD(Optimizer):
         gradients = self.gradients_centralization(gradients)
         gradients = self.scale_grad(gradients)
         lr = self.get_lr()
+        self.assignadd(self.global_step, self.global_step_increase_tensor)
         if self.is_group_lr:
             success = self.hyper_map_reverse(F.partial(_sgd_opt, self.momentum),
                                              lr, gradients, params, accum, stat, self.opt)

mindspore/nn/optim/thor.py

@@ -266,10 +266,10 @@ def thor(net, learning_rate, damping, momentum, weight_decay=0.0, loss_scale=1.0
             \otimes\left(G_{i}^{(k)}+\lambda I\right)^{-1}\right) \nabla_{w_{i}} J^{(k)}
         \end{array}
 
-    :math:`a_{i-1}` represents the input of i-th layer,and which is the activations of previous layer.
-    :math:`D_{s_i}` represents the derivative of the loss function of the output of the i-th layer.
+    :math:`a_{i-1}` represents the input of :math:`i`-th layer,and which is the activations of previous layer.
+    :math:`D_{s_i}` represents the derivative of the loss function of the output of the :math:`i`-th layer.
     :math:`I` represents the identity matrix.
-    :math:`\lambda` represents :math:`damping`, :math:`g_i` represents gradients of the i-th layer.
+    :math:`\lambda` represents :math:`damping`, :math:`g_i` represents gradients of the :math:`i`-th layer.
     :math:`\otimes` represents Kronecker product, :math:`\gamma` represents 'learning rate'.
 
     Note:
@@ -290,14 +290,15 @@ def thor(net, learning_rate, damping, momentum, weight_decay=0.0, loss_scale=1.0
 
         momentum (float): Hyper-parameter of type float, means momentum for the moving average. It must be at least 0.0.
 
-        weight_decay (int, float): Weight decay (L2 penalty). It must be equal to or greater than 0.0. Default: 0.0.
+        weight_decay (int, float): Weight decay (L2 penalty). It must be equal to or greater than 0.0.
+            Default: ``0.0`` .
 
         loss_scale (float): A value for the loss scale. It must be greater than 0.0. In general, use the
-            default value. Default: 1.0.
+            default value. Default: ``1.0`` .
 
-        batch_size (int): The size of a batch. Default: 32
+        batch_size (int): The size of a batch. Default: ``32`` .
 
-        use_nesterov (bool): Enable Nesterov momentum. Default: False.
+        use_nesterov (bool): Enable Nesterov momentum. Default: ``False`` .
 
         decay_filter (function): A function to determine which layers the weight decay applied to. And it
             only works when the weight_decay > 0. Default: lambda x: x.name not in []
@@ -305,13 +306,13 @@ def thor(net, learning_rate, damping, momentum, weight_decay=0.0, loss_scale=1.0
         split_indices (list): Set allreduce fusion strategy by A/G layer indices . Only works when distributed
             computing. ResNet50 as an example, there are 54 layers of A/G respectively, when split_indices is set
             to [26, 53], it means A/G is divided into two groups to allreduce,  one is 0~26 layer, and the other
-            is 27~53. Default: None
+            is 27~53. Default: ``None`` .
 
-        enable_clip_grad (bool): Whether to clip the gradients. Default: False
+        enable_clip_grad (bool): Whether to clip the gradients. Default: ``False`` .
 
         frequency(int): The update interval of A/G and :math:`A^{-1}/G^{-1}`. When frequency equals N
             (N is greater than 1), A/G and :math:`A^{-1}/G^{-1}` will be updated every N steps,
-            and other steps will use the stale A/G and :math:`A^{-1}/G^{-1}` to update weights. Default: 100.
+            and other steps will use the stale A/G and :math:`A^{-1}/G^{-1}` to update weights. Default: ``100`` .
 
     Inputs:
         - **gradients** (tuple[Tensor]) - The gradients of `params`, the shape is the same as `params`.
@@ -333,21 +334,18 @@ def thor(net, learning_rate, damping, momentum, weight_decay=0.0, loss_scale=1.0
         ``Ascend`` ``GPU``
 
     Examples:
-        .. note::
-            Before running the following example, you need to customize the network Net and
-            dataset preparation function create_dataset. Refer to
-            `Building a Network <https://www.mindspore.cn/tutorials/en/r2.0/beginner/model.html>`_
-            and `Dataset <https://www.mindspore.cn/tutorials/en/r2.0/beginner/dataset.html>`_ .
-
         >>> import mindspore as ms
-        >>> from mindspore.nn import thor
         >>> from mindspore import nn
         >>> from mindspore import Tensor
         >>>
-        >>> net = Net()
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
+        >>> # Create the dataset taking MNIST as an example. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
         >>> dataset = create_dataset()
         >>> temp = Tensor([4e-4, 1e-4, 1e-5, 1e-5], mstype.float32)
-        >>> optim = thor(net, learning_rate=temp, damping=temp, momentum=0.9, loss_scale=128, frequency=4)
+        >>> optim = nn.thor(net, learning_rate=temp, damping=temp, momentum=0.9, loss_scale=128, frequency=4)
         >>> loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
         >>> loss_scale = ms.FixedLossScaleManager(128, drop_overflow_update=False)
         >>> model = ms.Model(net, loss_fn=loss, optimizer=optim, loss_scale_manager=loss_scale, metrics={'acc'},
@@ -355,8 +353,6 @@ def thor(net, learning_rate, damping, momentum, weight_decay=0.0, loss_scale=1.0
         >>> model = ms.ConvertModelUtils.convert_to_thor_model(model=model, network=net, loss_fn=loss, optimizer=optim,
         ...                                                 loss_scale_manager=loss_scale, metrics={'acc'},
         ...                                                 amp_level="O2", keep_batchnorm_fp32=False)
-        >>> loss_cb = ms.LossMonitor()
-        >>> model.train(1, dataset, callbacks=loss_cb, sink_size=4, dataset_sink_mode=True)
 
     """
     context.set_context(max_call_depth=10000)
@@ -428,7 +424,7 @@ class ThorGpu(Optimizer):
         self.matmul = P.MatMul()
         self.assign = P.Assign()
         self.mul = P.Mul()
-        self.gather = P.GatherV2()
+        self.gather = P.Gather()
         self.one = Tensor(1, mstype.int32)
         self.feature_map = Tensor(1.0, mstype.float32)
         self.axis = 0
@@ -657,6 +653,7 @@ class ThorGpu(Optimizer):
             gradients = self.hyper_map(F.partial(apply_decay, self.weight_decay), self.decay_flags, params, gradients)
         gradients = clip_gradient(self.enable_clip_grad, gradients)
         lr = self.get_lr()
+        self.assignadd(self.global_step, self.global_step_increase_tensor)
         success = self.hyper_map(F.partial(_momentum_opt, self.opt, self.momentum, lr), gradients, params, moments)
         return success
 
@@ -681,7 +678,7 @@ class ThorAscend(Optimizer):
         self.g_normalizer = ParameterTuple(filter(lambda x: 'g_normalizer' in x.name, net.get_parameters()))
         logger.info("matrix_a_cov len is {}".format(len(self.matrix_a_cov)))
         self._define_ascend_operator()
-        self.C0 = 16
+        self.c0 = 16
         self.device_shape_pad_flag = ()
         self.diag_block_dim = 128
         self.matrix_a = ()
@@ -743,7 +740,7 @@ class ThorAscend(Optimizer):
         self.log = P.Log()
         self.exp = P.Exp()
         self.sqrt = P.Sqrt()
-        self.gather = P.GatherV2()
+        self.gather = P.Gather()
         self.assign = P.Assign()
         self.cast = P.Cast()
         self.eye = P.Eye()
@@ -989,8 +986,8 @@ class ThorAscend(Optimizer):
             kernel_hw = weight_shape[2] * weight_shape[3]
             in_channels = weight_shape[1]
             matrix_a_inv = self.reshape(matrix_a_inv, (kernel_hw, in_channels, kernel_hw, in_channels))
-            matrix_a_inv = P.Pad(((0, 0), (0, self.C0 - in_channels), (0, 0),
-                                  (0, self.C0 - in_channels)))(matrix_a_inv)
+            matrix_a_inv = P.Pad(((0, 0), (0, self.c0 - in_channels), (0, 0),
+                                  (0, self.c0 - in_channels)))(matrix_a_inv)
         return matrix_a_inv
 
     def _get_ainv_ginv_amax_gmax_list(self, gradients, damping_step, matrix_a_allreduce, matrix_g_allreduce,
@@ -1308,5 +1305,6 @@ class ThorAscend(Optimizer):
             gradients = self.hyper_map(F.partial(apply_decay, self.weight_decay), self.decay_flags, params, gradients)
         gradients = clip_gradient(self.enable_clip_grad, gradients)
         lr = self.get_lr()
+        self.assignadd(self.global_step, self.global_step_increase_tensor)
         success = self.hyper_map(F.partial(_momentum_opt, self.opt, self.momentum, lr), gradients, params, moments)
         return success

mindspore/nn/probability/bijector/bijector.py

@@ -16,6 +16,7 @@
 from mindspore import context
 from mindspore.nn.cell import Cell
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.common import dtype as mstype
 from mindspore.common.tensor import Tensor
@@ -33,11 +34,11 @@ class Bijector(Cell):
     then :math:`Y = g(X)` is the random variable following the transformed distribution.
 
     Args:
-        is_constant_jacobian (bool): Whether the Bijector has constant derivative. Default: False.
-        is_injective (bool): Whether the Bijector is a one-to-one mapping. Default: True.
-        name (str): The name of the Bijector. Default: None.
-        dtype (mindspore.dtype): The type of the distributions that the Bijector can operate on. Default: None.
-        param (dict): The parameters used to initialize the Bijector. Default: None.
+        is_constant_jacobian (bool): Whether the Bijector has constant derivative. Default: ``False`` .
+        is_injective (bool): Whether the Bijector is a one-to-one mapping. Default: ``True`` .
+        name (str): The name of the Bijector. Default: ``None`` .
+        dtype (mindspore.dtype): The type of the distributions that the Bijector can operate on. Default: ``None`` .
+        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.
@@ -96,7 +97,6 @@ class Bijector(Cell):
         self.cast_base = P.Cast()
         self.dtype_base = P.DType()
         self.shape_base = P.Shape()
-        self.fill_base = P.Fill()
         self.sametypeshape_base = inner.SameTypeShape()
         self.issubclass_base = inner.IsSubClass()
 
@@ -140,13 +140,13 @@ class Bijector(Cell):
             if self.issubclass_base(value_type, mstype.float_):
                 return value
             return raise_type_error('input value of bijector', value_type, mstype.float_)
-        dtype_tensor = self.fill_base(self.dtype, self.shape_base(value), 0.0)
+        dtype_tensor = F.fill(self.dtype, self.shape_base(value), 0.0)
         self.sametypeshape_base(value, dtype_tensor)
         return value
 
     def _shape_mapping(self, shape):
-        shape_tensor = self.fill_base(self.parameter_type, shape, 0.0)
-        dist_shape_tensor = self.fill_base(
+        shape_tensor = F.fill(self.parameter_type, shape, 0.0)
+        dist_shape_tensor = F.fill(
             self.parameter_type, self.batch_shape, 0.0)
         return (shape_tensor + dist_shape_tensor).shape
 
@@ -165,7 +165,7 @@ class Bijector(Cell):
             self.common_dtype = None
         # cast value to a tensor if it is not None
         if isinstance(value, bool) or value is None:
-            raise TypeError("{} cannot be type {}".format(name, type(value)))
+            raise TypeError(f"{name} cannot be type {type(value)}")
         value_t = Tensor(value)
         # if the bijector's dtype is not specified
         if self.dtype is None:
@@ -189,7 +189,7 @@ class Bijector(Cell):
         """
         Calculate batch_shape based on parameters.
         """
-        if 'param_dict' not in self.parameters.keys():
+        if 'param_dict' not in self.parameters:
             return None
         param_dict = self.parameters.get('param_dict')
         broadcast_shape_tensor = None

mindspore/nn/probability/bijector/exp.py

@@ -25,7 +25,7 @@ class Exp(PowerTransform):
         Y = \exp(x).
 
     Args:
-        name (str): The name of the Bijector. Default: 'Exp'.
+        name (str): The name of the Bijector. Default: ``'Exp'`` .
 
     Supported Platforms:
         ``Ascend`` ``GPU``

mindspore/nn/probability/bijector/gumbel_cdf.py

@@ -28,9 +28,9 @@ class GumbelCDF(Bijector):
         Y = \exp(-\exp(\frac{-(X - loc)}{scale}))
 
     Args:
-        loc (float, list, numpy.ndarray, Tensor): The location. Default: 0.0.
-        scale (float, list, numpy.ndarray, Tensor): The scale. Default: 1.0.
-        name (str): The name of the Bijector. Default: 'GumbelCDF'.
+        loc (float, list, numpy.ndarray, Tensor): The location. Default: ``0.0`` .
+        scale (float, list, numpy.ndarray, Tensor): The scale. Default: ``1.0`` .
+        name (str): The name of the Bijector. Default: ``'GumbelCDF'`` .
 
     Note:
         `scale` must be greater than zero.

mindspore/nn/probability/bijector/invert.py

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

mindspore/nn/probability/bijector/power_transform.py

@@ -14,6 +14,7 @@
 # ============================================================================
 """PowerTransform Bijector"""
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from ..distribution._utils.utils import check_greater_equal_zero
 from ..distribution._utils.custom_ops import exp_generic, log_generic
 from .bijector import Bijector
@@ -34,8 +35,8 @@ class PowerTransform(Bijector):
     This Bijector is equivalent to the :class:`mindspore.nn.probability.bijector.Exp` bijector when `c=0`.
 
     Args:
-        power (float, list, numpy.ndarray, Tensor): The scale factor. Default: 0.
-        name (str): The name of the bijector. Default: 'PowerTransform'.
+        power (float, list, numpy.ndarray, Tensor): The scale factor. Default: ``0`` .
+        name (str): The name of the bijector. Default: ``'PowerTransform'`` .
 
     Note:
         The dtype of `power` must be float.
@@ -68,10 +69,7 @@ class PowerTransform(Bijector):
         >>> print(ans4.shape)
         (3,)
     """
-
-    def __init__(self,
-                 power=0.,
-                 name='PowerTransform'):
+    def __init__(self, power=0., name='PowerTransform'):
         param = dict(locals())
         param['param_dict'] = {'power': power}
         super(PowerTransform, self).__init__(name=name, param=param)
@@ -84,7 +82,6 @@ class PowerTransform(Bijector):
         self.equal_base = P.Equal()
         self.exp = exp_generic
         self.expm1 = P.Expm1()
-        self.fill = P.Fill()
         self.log = log_generic
         self.log1p = P.Log1p()
         self.select_base = P.Select()
@@ -116,17 +113,18 @@ class PowerTransform(Bijector):
         power_local = self.cast_param_by_value(x, self.power)
 
         # broad cast the value of x and power
-        ones = self.fill(self.dtypeop(power_local),
-                         self.shape(x + power_local), 1.)
+        ones = F.fill(self.dtypeop(power_local), self.shape(x + power_local),
+                      1.)
         power_local = power_local * ones
         x = x * ones
-        safe_power = self.select_base(self.equal_base(power_local, P.ZerosLike()(power_local)),
-                                      ones,
-                                      power_local)
-
-        forward_v = self.select_base(self.equal_base(power_local, P.ZerosLike()(power_local)),
-                                     self.exp(x),
-                                     self.exp(self.log1p(x * safe_power) / safe_power))
+        safe_power = self.select_base(
+            self.equal_base(power_local,
+                            P.ZerosLike()(power_local)), ones, power_local)
+
+        forward_v = self.select_base(
+            self.equal_base(power_local,
+                            P.ZerosLike()(power_local)), self.exp(x),
+            self.exp(self.log1p(x * safe_power) / safe_power))
         return forward_v
 
     def _inverse(self, y):
@@ -137,17 +135,18 @@ class PowerTransform(Bijector):
         power_local = self.cast_param_by_value(y, self.power)
 
         # broad cast the value of x and power
-        ones = self.fill(self.dtypeop(power_local),
-                         self.shape(y + power_local), 1.)
+        ones = F.fill(self.dtypeop(power_local), self.shape(y + power_local),
+                      1.)
         power_local = power_local * ones
         y = y * ones
-        safe_power = self.select_base(self.equal_base(power_local, P.ZerosLike()(power_local)),
-                                      ones,
-                                      power_local)
+        safe_power = self.select_base(
+            self.equal_base(power_local,
+                            P.ZerosLike()(power_local)), ones, power_local)
 
-        inverse_v = self.select_base(self.equal_base(power_local, P.ZerosLike()(power_local)),
-                                     self.log(y),
-                                     self.expm1(self.log(y) * safe_power) / safe_power)
+        inverse_v = self.select_base(
+            self.equal_base(power_local,
+                            P.ZerosLike()(power_local)), self.log(y),
+            self.expm1(self.log(y) * safe_power) / safe_power)
 
         return inverse_v
 
@@ -167,14 +166,15 @@ class PowerTransform(Bijector):
         power_local = self.cast_param_by_value(x, self.power)
 
         # broad cast the value of x and power
-        ones = self.fill(self.dtypeop(power_local),
-                         self.shape(x + power_local), 1.)
+        ones = F.fill(self.dtypeop(power_local), self.shape(x + power_local),
+                      1.)
         power_local = power_local * ones
         x = x * ones
 
-        forward_log_j = self.select_base(self.equal_base(power_local, P.ZerosLike()(power_local)),
-                                         x,
-                                         (1. / power_local - 1) * self.log1p(x * power_local))
+        forward_log_j = self.select_base(
+            self.equal_base(power_local,
+                            P.ZerosLike()(power_local)), x,
+            (1. / power_local - 1) * self.log1p(x * power_local))
 
         return forward_log_j
 

mindspore/nn/probability/bijector/scalar_affine.py

@@ -29,9 +29,9 @@ class ScalarAffine(Bijector):
     where a is the scale factor and 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.
-        name (str): The name of the bijector. Default: 'ScalarAffine'.
+        scale (float, list, numpy.ndarray, Tensor): The scale factor. Default: ``1.0`` .
+        shift (float, list, numpy.ndarray, Tensor): The shift factor. Default: ``0.0`` .
+        name (str): The name of the bijector. Default: ``'ScalarAffine'`` .
 
     Note:
         The dtype of `shift` and `scale` must be float.