mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/nn/probability/bijector/softplus.py

@@ -15,6 +15,7 @@
 """Softplus Bijector"""
 import numpy as np
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.nn.layer.activation import LogSigmoid
 from ..distribution._utils.custom_ops import exp_generic, log_generic
 from .bijector import Bijector
@@ -31,8 +32,8 @@ class Softplus(Bijector):
     where k is the sharpness factor.
 
     Args:
-        sharpness (float, list, numpy.ndarray, Tensor): The scale factor. Default: 1.0.
-        name (str): The name of the Bijector. Default: 'Softplus'.
+        sharpness (float, list, numpy.ndarray, Tensor): The scale factor. Default: ``1.0`` .
+        name (str): The name of the Bijector. Default: ``'Softplus'`` .
 
     Note:
         The dtype of `sharpness` must be float.
@@ -84,7 +85,6 @@ class Softplus(Bijector):
         self.abs = P.Abs()
         self.dtypeop = P.DType()
         self.cast = P.Cast()
-        self.fill = P.Fill()
         self.greater = P.Greater()
         self.less = P.Less()
         self.log_sigmoid = LogSigmoid()
@@ -103,7 +103,7 @@ class Softplus(Bijector):
         too_large = self.greater(x, -self.threshold)
         too_small_value = self.exp(x)
         too_large_value = x
-        ones = self.fill(self.dtypeop(x), self.shape(x), 1.0)
+        ones = F.fill(self.dtypeop(x), self.shape(x), 1.0)
         too_small_or_too_large = self.logicalor(too_small, too_large)
         x = self.select(too_small_or_too_large, ones, x)
         y = self.log(self.exp(x) + 1.0)
@@ -119,7 +119,7 @@ class Softplus(Bijector):
         too_large = self.greater(x, (-1) * self.threshold)
         too_small_value = self.log(x)
         too_large_value = x
-        ones = self.fill(self.dtypeop(x), self.shape(x), 1.0)
+        ones = F.fill(self.dtypeop(x), self.shape(x), 1.0)
         too_small_or_too_large = self.logicalor(too_small, too_large)
         x = self.select(too_small_or_too_large, ones, x)
         y = x + self.log(self.abs(self.expm1((-1)*x)))

mindspore/nn/probability/bnn_layers/bnn_cell_wrapper.py

@@ -27,8 +27,10 @@ class WithBNNLossCell(Cell):
     Args:
         backbone (Cell): The target network.
         loss_fn (Cell): The loss function used to compute loss.
-        dnn_factor(int, float): The coefficient of backbone's loss, which is computed by the loss function. Default: 1.
-        bnn_factor(int, float): The coefficient of KL loss, which is the KL divergence of Bayesian layer. Default: 1.
+        dnn_factor(int, float): The coefficient of backbone's loss, which is computed by the loss function.
+            Default: ``1`` .
+        bnn_factor(int, float): The coefficient of KL loss, which is the KL divergence of Bayesian layer.
+            Default: ``1`` .
 
     Inputs:
         - **data** (Tensor) - Tensor of shape :math:`(N, \ldots)`.

mindspore/nn/probability/bnn_layers/conv_variational.py

@@ -157,11 +157,11 @@ class ConvReparam(_ConvVariational):
         stride(Union[int, tuple[int]]): The distance of kernel moving,
             an integer number represents that the height and width of movement
             are both strides, or a tuple of two integers numbers represents that
-            height and width of movement respectively. Default: 1.
+            height and width of movement respectively. Default: ``1`` .
         pad_mode (str): Specifies the padding mode. The optional values are
-            "same", "valid", and "pad". Default: "same".
+            ``"same"`` , ``"valid"`` , and ``"pad"`` . Default: ``"same"`` .
 
-            - same: Adopts the way of completion. Output height and width
+            - ``"same"``: Adopts the way of completion. Output height and width
               will be the same as the input.
               The total number of padding will be calculated for in horizontal and
               vertical directions and evenly distributed to top and bottom,
@@ -169,43 +169,43 @@ class ConvReparam(_ConvVariational):
               will be done from the bottom and the right side. If this mode
               is set, `padding` must be 0.
 
-            - valid: Adopts the way of discarding. The possible largest
+            - ``"valid"``: Adopts the way of discarding. The possible largest
               height and width of the output will be returned without padding.
               Extra pixels will be discarded. If this mode is set, `padding`
               must be 0.
 
-            - pad: Implicit paddings on both sides of the input. The number
+            - ``"pad"``: Implicit paddings on both sides of the input. The number
               of `padding` will be padded to the input Tensor borders.
               `padding` must be greater than or equal to 0.
 
         padding (Union[int, tuple[int]]): Implicit paddings on both sides of
-            the input. Default: 0.
+            the input. Default: ``0`` .
         dilation (Union[int, tuple[int]]): The data type is an integer or a tuple
             of 2 integers. This parameter specifies the dilation rate of the
             dilated convolution. If set to be :math:`k > 1`,
             there will be :math:`k - 1` pixels skipped for each sampling
             location. Its value must be greater or equal to 1 and bounded
-            by the height and width of the input. Default: 1.
+            by the height and width of the input. Default: ``1`` .
         group (int): Splits filter into groups, `in_ channels` and
             `out_channels` must be divisible by the number of groups.
-            Default: 1.
+            Default: ``1`` .
         has_bias (bool): Specifies whether the layer uses a bias vector.
-            Default: False.
+            Default: ``False`` .
         weight_prior_fn (Cell): The prior distribution for weight.
             It must return a mindspore distribution instance.
-            Default: NormalPrior. (which creates an instance of standard
+            Default: ``NormalPrior`` . (which creates an instance of standard
             normal distribution). The current version only supports normal distribution.
         weight_posterior_fn (function): The posterior distribution for sampling weight.
             It must be a function handle which returns a mindspore
-            distribution instance. Default: normal_post_fn.
+            distribution instance. Default: ``normal_post_fn`` .
             The current version only supports normal distribution.
         bias_prior_fn (Cell): The prior distribution for bias vector. It must return
-            a mindspore distribution. Default: NormalPrior(which creates an
+            a mindspore distribution. Default: ``NormalPrior`` (which creates an
             instance of standard normal distribution). The current version
             only supports normal distribution.
         bias_posterior_fn (function): The posterior distribution for sampling bias vector.
             It must be a function handle which returns a mindspore
-            distribution instance. Default: normal_post_fn.
+            distribution instance. Default: ``normal_post_fn`` .
             The current version only supports normal distribution.
 
     Inputs:

mindspore/nn/probability/bnn_layers/dense_variational.py

@@ -136,23 +136,23 @@ class DenseReparam(_DenseVariational):
         activation (str, Cell): A regularization function applied to the output of the layer.
             The type of `activation` can be a string (eg. 'relu') or a Cell (eg. nn.ReLU()).
             Note that if the type of activation is Cell, it must be instantiated beforehand.
-            Default: None.
-        has_bias (bool): Specifies whether the layer uses a bias vector. Default: False.
+            Default: ``None`` .
+        has_bias (bool): Specifies whether the layer uses a bias vector. Default: ``False`` .
         weight_prior_fn (Cell): The prior distribution for weight.
             It must return a mindspore distribution instance.
-            Default: NormalPrior. (which creates an instance of standard
+            Default: ``NormalPrior`` . (which creates an instance of standard
             normal distribution). The current version only supports normal distribution.
         weight_posterior_fn (function): The posterior distribution for sampling weight.
             It must be a function handle which returns a mindspore
-            distribution instance. Default: normal_post_fn.
+            distribution instance. Default: ``normal_post_fn`` .
             The current version only supports normal distribution.
         bias_prior_fn (Cell): The prior distribution for bias vector. It must return
-            a mindspore distribution. Default: NormalPrior(which creates an
+            a mindspore distribution. Default: ``NormalPrior`` (which creates an
             instance of standard normal distribution). The current version
             only supports normal distribution.
         bias_posterior_fn (function): The posterior distribution for sampling bias vector.
             It must be a function handle which returns a mindspore
-            distribution instance. Default: normal_post_fn.
+            distribution instance. Default: ``normal_post_fn`` .
             The current version only supports normal distribution.
 
     Inputs:
@@ -230,23 +230,23 @@ class DenseLocalReparam(_DenseVariational):
         activation (str, Cell): A regularization function applied to the output of the layer.
             The type of `activation` can be a string (eg. 'relu') or a Cell (eg. nn.ReLU()).
             Note that if the type of activation is Cell, it must be instantiated beforehand.
-            Default: None.
-        has_bias (bool): Specifies whether the layer uses a bias vector. Default: False.
+            Default: ``None`` .
+        has_bias (bool): Specifies whether the layer uses a bias vector. Default: ``False`` .
         weight_prior_fn (Cell): The prior distribution for weight.
             It must return a mindspore distribution instance.
-            Default: NormalPrior. (which creates an instance of standard
+            Default: ``NormalPrior`` . (which creates an instance of standard
             normal distribution). The current version only supports normal distribution.
         weight_posterior_fn (function): The posterior distribution for sampling weight.
             It must be a function handle which returns a mindspore
-            distribution instance. Default: normal_post_fn.
+            distribution instance. Default: ``normal_post_fn`` .
             The current version only supports normal distribution.
         bias_prior_fn (Cell): The prior distribution for bias vector. It must return
-            a mindspore distribution. Default: NormalPrior(which creates an
+            a mindspore distribution. Default: ``NormalPrior`` (which creates an
             instance of standard normal distribution). The current version
             only supports normal distribution.
         bias_posterior_fn (function): The posterior distribution for sampling bias vector.
             It must be a function handle which returns a mindspore
-            distribution instance. Default: normal_post_fn.
+            distribution instance. Default: ``normal_post_fn`` .
             The current version only supports normal distribution.
 
     Inputs:

mindspore/nn/probability/bnn_layers/layer_distribution.py

@@ -30,9 +30,9 @@ class NormalPrior(Cell):
 
     Args:
         dtype (mindspore.dtype): The argument is used to define the data type of the output tensor.
-            Default: mindspore.float32.
-        mean (int, float): Mean of normal distribution. Default: 0.
-        std (int, float): Standard deviation of normal distribution. Default: 0.1.
+            Default: ``mindspore.float32`` .
+        mean (int, float): Mean of normal distribution. Default: ``0`` .
+        std (int, float): Standard deviation of normal distribution. Default: ``0.1`` .
 
     Returns:
         Cell, a normal distribution.
@@ -56,12 +56,13 @@ class NormalPosterior(Cell):
         name (str): Name prepended to trainable parameter.
         shape (list, tuple): Shape of the mean and standard deviation.
         dtype (mindspore.dtype): The argument is used to define the data type of the output tensor.
-            Default: mindspore.float32.
-        loc_mean (int, float): Mean of distribution to initialize trainable parameters. Default: 0.
-        loc_std (int, float): Standard deviation of distribution to initialize trainable parameters. Default: 0.1.
-        untransformed_scale_mean (int, float): Mean of distribution to initialize trainable parameters. Default: -5.
+            Default: ``mindspore.float32`` .
+        loc_mean (int, float): Mean of distribution to initialize trainable parameters. Default: ``0`` .
+        loc_std (int, float): Standard deviation of distribution to initialize trainable parameters. Default: ``0.1`` .
+        untransformed_scale_mean (int, float): Mean of distribution to initialize trainable parameters.
+            Default: ``-5`` .
         untransformed_scale_std (int, float): Standard deviation of distribution to initialize trainable parameters.
-            Default: 0.1.
+            Default: ``0.1`` .
 
     Returns:
         Cell, a normal distribution.

mindspore/nn/probability/distribution/_utils/custom_ops.py

@@ -15,8 +15,17 @@
 """Utility functions to help distribution class."""
 import numpy as np
 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.ops.primitive import constexpr
 from mindspore.common import dtype as mstype
+from .utils import CheckTensor
+
+
+@constexpr(check=False)
+def _check_tensor(x, name):
+    CheckTensor()(x, name)
+    return x
 
 
 def exp_generic(input_x):
@@ -44,7 +53,6 @@ def log_generic(input_x):
     log = P.Log()
     less = P.Less()
     lessequal = P.LessEqual()
-    fill = P.Fill()
     cast = P.Cast()
     dtype = P.DType()
     shape = P.Shape()
@@ -53,8 +61,8 @@ def log_generic(input_x):
 
     if not checktype(dtype(input_x), mstype.float_):
         input_x = cast(input_x, mstype.float32)
-    nan = fill(dtype(input_x), shape(input_x), np.nan)
-    inf = fill(dtype(input_x), shape(input_x), np.inf)
+    nan = F.fill(dtype(input_x), shape(input_x), np.nan)
+    inf = F.fill(dtype(input_x), shape(input_x), np.inf)
     neg_x = less(input_x, 0.0)
     nonpos_x = lessequal(input_x, 0.0)
     log_x = log(input_x)
@@ -63,6 +71,14 @@ def log_generic(input_x):
     return select(neg_x, nan, result)
 
 
+def log_generic_with_check(x):
+    """
+    log generic with input check
+    """
+    _check_tensor(x, "the input of log_generic")
+    return log_generic(x)
+
+
 def log1p_generic(x):
     """
     Log1p ops on GPU device or when device_target == GPU.

mindspore/nn/probability/distribution/_utils/utils.py

@@ -315,7 +315,7 @@ class CheckTensor(PrimitiveWithInfer):
     def __infer__(self, x, name):
         src_type = x['dtype']
         validator.check_subclass(
-            "input", src_type, [mstype.tensor], name["value"])
+            "input", src_type, [mstype.tensor_type], name["value"])
 
         out = {'shape': None,
                'dtype': None,

mindspore/nn/probability/distribution/bernoulli.py

@@ -15,6 +15,7 @@
 """Bernoulli Distribution"""
 from mindspore.common import dtype as mstype
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 from mindspore import _checkparam as Validator
 from .distribution import Distribution
@@ -29,10 +30,10 @@ class Bernoulli(Distribution):
     and the probability mass function as :math:`P(X = 0) = p, P(X = 1) = 1-p`.
 
     Args:
-        probs (float, list, numpy.ndarray, Tensor): The probability of that the outcome is 1. 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.int32.
-        name (str): The name of the distribution. Default: 'Bernoulli'.
+        probs (float, list, numpy.ndarray, Tensor): The probability of that the outcome is 1. 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.int32`` .
+        name (str): The name of the distribution. Default: ``'Bernoulli'`` .
 
     Note:
         `probs` must be a proper probability (0 < p < 1).
@@ -151,7 +152,6 @@ class Bernoulli(Distribution):
         self.cast = P.Cast()
         self.const = P.ScalarToTensor()
         self.floor = P.Floor()
-        self.fill = P.Fill()
         self.less = P.Less()
         self.shape = P.Shape()
         self.select = P.Select()
@@ -200,8 +200,8 @@ class Bernoulli(Distribution):
             MODE(B) = 1 if probs1 > 0.5 else = 0
         """
         probs1 = self._check_param_type(probs1)
-        zeros = self.fill(self.dtype, self.shape(probs1), 0.0)
-        ones = self.fill(self.dtype, self.shape(probs1), 1.0)
+        zeros = F.fill(self.dtype, self.shape(probs1), 0.0)
+        ones = F.fill(self.dtype, self.shape(probs1), 1.0)
         comp = self.less(0.5, probs1)
         return self.select(comp, ones, zeros)
 
@@ -278,9 +278,9 @@ class Bernoulli(Distribution):
         probs0 = self.broadcast((1.0 - probs1), broadcast_shape_tensor)
         comp_zero = self.less(value, 0.0)
         comp_one = self.less(value, 1.0)
-        zeros = self.fill(self.parameter_type, self.shape(
+        zeros = F.fill(self.parameter_type, self.shape(
             broadcast_shape_tensor), 0.0)
-        ones = self.fill(self.parameter_type, self.shape(
+        ones = F.fill(self.parameter_type, self.shape(
             broadcast_shape_tensor), 1.0)
         less_than_zero = self.select(comp_zero, zeros, probs0)
         return self.select(comp_one, less_than_zero, ones)

mindspore/nn/probability/distribution/beta.py

@@ -15,6 +15,7 @@
 """Beta Distribution"""
 import numpy as np
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 import mindspore.nn as nn
 from mindspore import _checkparam as Validator
@@ -36,12 +37,12 @@ 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 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.
-        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'.
+          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'`` .
 
     Note:
         - `concentration1` and `concentration0` must be greater than zero.
@@ -186,7 +187,6 @@ class Beta(Distribution):
         self.pow = P.Pow()
         self.squeeze = P.Squeeze(0)
         self.cast = P.Cast()
-        self.fill = P.Fill()
         self.shape = P.Shape()
         self.select = P.Select()
         self.logicaland = P.LogicalAnd()
@@ -266,7 +266,7 @@ class Beta(Distribution):
         comp2 = self.greater(concentration0, 1.)
         cond = self.logicaland(comp1, comp2)
         batch_shape = self.shape(concentration1 + concentration0)
-        nan = self.fill(self.dtype, batch_shape, np.nan)
+        nan = F.fill(self.dtype, batch_shape, np.nan)
         mode = (concentration1 - 1.) / (concentration1 + concentration0 - 2.)
         return self.select(cond, mode, nan)
 
@@ -379,7 +379,7 @@ class Beta(Distribution):
             sample_shape = (1,)
         else:
             sample_shape = origin_shape
-        ones = self.fill(self.dtype, sample_shape, 1.0)
+        ones = F.fill(self.dtype, sample_shape, 1.0)
         sample_gamma1 = C.gamma(
             sample_shape, alpha=concentration1, beta=ones, seed=self.seed)
         sample_gamma2 = C.gamma(

mindspore/nn/probability/distribution/categorical.py

@@ -15,7 +15,9 @@
 """Categorical Distribution"""
 import numpy as np
 from mindspore import context
+from mindspore.common import Tensor
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 from mindspore.ops.functional import stop_gradient
 from mindspore.ops.operations import _inner_ops as inner
@@ -26,7 +28,7 @@ from mindspore.common import dtype as mstype
 from .distribution import Distribution
 from ._utils.utils import check_prob, check_sum_equal_one, check_rank,\
     check_distribution_name
-from ._utils.custom_ops import exp_generic, log_generic, broadcast_to
+from ._utils.custom_ops import exp_generic, log_generic, broadcast_to, log_generic_with_check
 
 
 class Categorical(Distribution):
@@ -36,10 +38,10 @@ class Categorical(Distribution):
     and the probability mass function as :math:`P(X = i) = p_i, i = 1, ..., k`.
 
     Args:
-        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.
+        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`` .
 
     Note:
         `probs` must have rank at least 1, values are proper probabilities and sum to 1.
@@ -148,7 +150,6 @@ class Categorical(Distribution):
         self.dtypeop = P.DType()
         self.exp = exp_generic
         self.expand_dim = P.ExpandDims()
-        self.fill = P.Fill()
         self.gather = P.GatherNd()
         self.greater = P.Greater()
         self.issubclass = inner.IsSubClass()
@@ -156,6 +157,7 @@ class Categorical(Distribution):
         # when the graph kernel mode is enable
         # use Log directly as akg will handle the corner cases
         self.log = P.Log() if context.get_context("enable_graph_kernel") else log_generic
+        self.log_with_check = P.Log() if context.get_context("enable_graph_kernel") else log_generic_with_check
         self.log_softmax = P.LogSoftmax()
         self.logicor = P.LogicalOr()
         self.logicand = P.LogicalAnd()
@@ -253,8 +255,11 @@ class Categorical(Distribution):
         probs_b = self._check_value(probs_b, 'probs_b')
         probs_b = self.cast(probs_b, self.parameter_type)
         probs_a = self._check_param_type(probs)
-        logits_a = self.log(probs_a)
-        logits_b = self.log(probs_b)
+        if probs is None:
+            logits_a = self.log(probs_a)
+        else:
+            logits_a = self.log_with_check(probs_a)
+        logits_b = self.log_with_check(probs_b)
         return self.squeeze(self.reduce_sum(
             self.softmax(logits_a) * (self.log_softmax(logits_a) - (self.log_softmax(logits_b))), -1))
 
@@ -287,7 +292,7 @@ class Categorical(Distribution):
         # here we simulate casting to int but still keeping float dtype
         value = self.cast(value, self.dtypeop(probs))
 
-        zeros = self.fill(self.dtypeop(value), self.shape(value), 0.0)
+        zeros = F.fill(self.dtypeop(value), self.shape(value), 0.0)
         between_zero_neone = self.logicand(self.less(value, 0,),
                                            self.greater(value, -1.))
         value = self.select(between_zero_neone,
@@ -323,15 +328,18 @@ class Categorical(Distribution):
         value_clipped = self.clip_by_value(value, 0.0, num_classes - 1)
         value_clipped = self.cast(value_clipped, self.index_type)
         # create index from 0 ... NumOfLabels
-        index = self.reshape(nn.Range(0, self.shape(value)[0], 1)(), (-1, 1))
+        start = Tensor(0, self.index_type)
+        end = self.cast(self.shape(value)[0], self.index_type)
+        delta = Tensor(1, self.index_type)
+        index = self.reshape(ops.range(start, end, delta), (-1, 1))
         index = self.concat((index, value_clipped))
 
         # index into logit_pmf, fill in out_of_bound places with -inf
         # reshape into label shape N
         logits_pmf = self.gather(self.reshape(
             logits, (-1, num_classes)), index)
-        nan = self.fill(self.dtypeop(logits_pmf),
-                        self.shape(logits_pmf), self.nan)
+        nan = F.fill(self.dtypeop(logits_pmf), self.shape(logits_pmf),
+                     self.nan)
         logits_pmf = self.select(out_of_bound, nan, logits_pmf)
         ans = self.reshape(logits_pmf, label_shape)
         if drop_dim:
@@ -351,7 +359,7 @@ class Categorical(Distribution):
 
         value = self.cast(value, self.dtypeop(probs))
 
-        zeros = self.fill(self.dtypeop(value), self.shape(value), 0.0)
+        zeros = F.fill(self.dtypeop(value), self.shape(value), 0.0)
         between_zero_neone = self.logicand(
             self.less(value, 0,), self.greater(value, -1.))
         value = self.select(between_zero_neone, zeros, P.Floor()(value))
@@ -386,7 +394,7 @@ class Categorical(Distribution):
         # reshape probs and fill less_than_zero places with 0
         probs = self.reshape(probs, (-1, num_classes))
         cdf = self.gather(self.cumsum(probs, 1), index)
-        zeros = self.fill(self.dtypeop(cdf), self.shape(cdf), 0.0)
+        zeros = F.fill(self.dtypeop(cdf), self.shape(cdf), 0.0)
         cdf = self.select(less_than_zero, zeros, cdf)
         cdf = self.reshape(cdf, label_shape)
 
@@ -417,7 +425,7 @@ class Categorical(Distribution):
             sample_shape = (1,)
 
         probs_2d = self.reshape(probs, (-1, num_classes))
-        sample_tensor = self.fill(self.dtype, shape, 1.0)
+        sample_tensor = F.fill(self.dtype, shape, 1.0)
         sample_tensor = self.reshape(sample_tensor, (-1, 1))
         num_sample = self.shape(sample_tensor)[0]
         samples = C.multinomial(probs_2d, num_sample, seed=self.seed)

mindspore/nn/probability/distribution/cauchy.py

@@ -35,11 +35,11 @@ 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.
-        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'.
+        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`` .
+        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'`` .
 
     Note:
         `scale` must be greater than zero.
@@ -170,7 +170,6 @@ class Cauchy(Distribution):
         self.const = P.ScalarToTensor()
         self.dtypeop = P.DType()
         self.exp = exp_generic
-        self.fill = P.Fill()
         self.less = P.Less()
         self.log = log_generic
         self.log1p = log1p_generic

mindspore/nn/probability/distribution/distribution.py

@@ -15,6 +15,7 @@
 """basic"""
 from mindspore import context
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.nn.cell import Cell
 from mindspore.ops.primitive import constexpr
 from mindspore.ops.operations import _inner_ops as inner
@@ -113,7 +114,6 @@ class Distribution(Cell):
         # ops needed for the base class
         self.cast_base = P.Cast()
         self.dtype_base = P.DType()
-        self.fill_base = P.Fill()
         self.sametypeshape_base = inner.SameTypeShape()
         self.sq_base = P.Square()
         self.sqrt_base = P.Sqrt()
@@ -194,11 +194,11 @@ class Distribution(Cell):
             if broadcast_shape is None:
                 broadcast_shape = self.shape_base(arg)
                 common_dtype = self.dtype_base(arg)
-                broadcast_shape_tensor = self.fill_base(
+                broadcast_shape_tensor = F.fill(
                     common_dtype, broadcast_shape, 1.0)
             else:
                 broadcast_shape = self.shape_base(arg + broadcast_shape_tensor)
-                broadcast_shape_tensor = self.fill_base(
+                broadcast_shape_tensor = F.fill(
                     common_dtype, broadcast_shape, 1.0)
                 arg = self.broadcast(arg, broadcast_shape_tensor)
                 # check if the arguments have the same dtype

mindspore/nn/probability/distribution/exponential.py

@@ -35,10 +35,10 @@ 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): 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'`` .
 
     Note:
         `rate` must be strictly greater than 0.

mindspore/nn/probability/distribution/gamma.py

@@ -15,6 +15,7 @@
 """Gamma Distribution"""
 import numpy as np
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.ops import composite as C
 import mindspore.nn as nn
 from mindspore import _checkparam as Validator
@@ -38,12 +39,12 @@ 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 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.
-        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'.
+          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'`` .
 
     Note:
         `concentration` and `rate` must be greater than zero.
@@ -185,13 +186,12 @@ class Gamma(Distribution):
         self.squeeze = P.Squeeze(0)
         self.cast = P.Cast()
         self.dtypeop = P.DType()
-        self.fill = P.Fill()
         self.shape = P.Shape()
         self.select = P.Select()
         self.greater = P.Greater()
-        self.lgamma = nn.LGamma()
+        self.lgamma = P.Lgamma()
         self.digamma = nn.DiGamma()
-        self.igamma = nn.IGamma()
+        self.igamma = P.Igamma()
 
     def extend_repr(self):
         """Display instance object as string."""
@@ -265,8 +265,8 @@ class Gamma(Distribution):
         """
         concentration, rate = self._check_param_type(concentration, rate)
         mode = (concentration - 1.) / rate
-        nan = self.fill(self.dtypeop(concentration),
-                        self.shape(concentration), np.nan)
+        nan = F.fill(self.dtypeop(concentration), self.shape(concentration),
+                     np.nan)
         comp = self.greater(concentration, 1.)
         return self.select(comp, mode, nan)