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

mindspore/nn/probability/distribution/geometric.py

@@ -15,6 +15,7 @@
 """Geometric Distribution"""
 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 import composite as C
 from mindspore import _checkparam as Validator
@@ -33,10 +34,10 @@ class Geometric(Distribution):
     trials when the first success is achieved.
 
     Args:
-        probs (float, list, numpy.ndarray, Tensor): The probability of success. Default: None.
-        seed (int): The seed 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: 'Geometric'.
+        probs (float, list, numpy.ndarray, Tensor): The probability of success. Default: ``None`` .
+        seed (int): The seed 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: ``'Geometric'`` .
 
     Note:
         `probs` must be a proper probability (0 < p < 1).
@@ -160,7 +161,6 @@ class Geometric(Distribution):
         self.cast = P.Cast()
         self.const = P.ScalarToTensor()
         self.dtypeop = P.DType()
-        self.fill = P.Fill()
         self.floor = P.Floor()
         self.issubclass = inner.IsSubClass()
         self.less = P.Less()
@@ -212,7 +212,7 @@ class Geometric(Distribution):
             MODE(Geo) = 0
         """
         probs1 = self._check_param_type(probs1)
-        return self.fill(self.dtype, self.shape(probs1), 0.)
+        return F.fill(self.dtype, self.shape(probs1), 0.)
 
     def _var(self, probs1=None):
         r"""
@@ -260,7 +260,7 @@ class Geometric(Distribution):
         value = self.floor(value)
         probs1 = self._check_param_type(probs1)
         pmf = self.exp(self.log(1.0 - probs1) * value + self.log(probs1))
-        zeros = self.fill(self.dtypeop(pmf), self.shape(pmf), 0.0)
+        zeros = F.fill(self.dtypeop(pmf), self.shape(pmf), 0.0)
         comp = self.less(value, zeros)
         return self.select(comp, zeros, pmf)
 
@@ -283,7 +283,7 @@ class Geometric(Distribution):
         probs1 = self._check_param_type(probs1)
         probs0 = 1.0 - probs1
         cdf = 1.0 - self.pow(probs0, value + 1.0)
-        zeros = self.fill(self.dtypeop(cdf), self.shape(cdf), 0.0)
+        zeros = F.fill(self.dtypeop(cdf), self.shape(cdf), 0.0)
         comp = self.less(value, zeros)
         return self.select(comp, zeros, cdf)
 

mindspore/nn/probability/distribution/gumbel.py

@@ -15,9 +15,9 @@
 """Gumbel Distribution"""
 import numpy as np
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
-import mindspore.nn as nn
 import mindspore.nn.probability.bijector as msb
 import mindspore.nn.probability.distribution as msd
 from .transformed_distribution import TransformedDistribution
@@ -39,9 +39,9 @@ class Gumbel(TransformedDistribution):
     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.
-        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'.
+        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'`` .
 
     Note:
         `scale` must be greater than zero.
@@ -102,8 +102,7 @@ class Gumbel(TransformedDistribution):
         self.const = P.ScalarToTensor()
         self.exp = exp_generic
         self.expm1 = P.Expm1()
-        self.fill = P.Fill()
-        self.lgamma = nn.LGamma()
+        self.lgamma = P.Lgamma()
         self.log = log_generic
         self.shape = P.Shape()
         self.squeeze = P.Squeeze(0)
@@ -164,7 +163,7 @@ class Gumbel(TransformedDistribution):
         """
         The mode of the distribution.
         """
-        return self.loc * self.fill(self.parameter_type, self.shape(self.scale), 1.0)
+        return self.loc * F.fill(self.parameter_type, self.shape(self.scale), 1.0)
 
     def _sd(self):
         r"""
@@ -174,7 +173,7 @@ class Gumbel(TransformedDistribution):
             STD(X) = \frac{\pi}{\sqrt(6)} * scale
         """
         scale = self.scale * \
-            self.fill(self.parameter_type, self.broadcast_shape, 1.0)
+            F.fill(self.parameter_type, self.broadcast_shape, 1.0)
         return scale * np.pi / self.sqrt(self.const(6., mstype.float32))
 
     def _entropy(self):
@@ -185,7 +184,7 @@ class Gumbel(TransformedDistribution):
             H(X) = 1. + \log(scale) + Euler-Mascheroni_constant
         """
         scale = self.scale * \
-            self.fill(self.parameter_type, self.broadcast_shape, 1.0)
+            F.fill(self.parameter_type, self.broadcast_shape, 1.0)
         return 1. + self.log(scale) + np.euler_gamma
 
     def _log_prob(self, value):

mindspore/nn/probability/distribution/half_normal.py

@@ -37,12 +37,12 @@ class HalfNormal(Distribution):
 
     Args:
         mean (Union[int, float, list, numpy.ndarray, Tensor], optional): The mean of the distribution.
-            If this arg is None, then the mean of the distribution will be passed in runtime. Default: None.
+            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.
-            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.
-        name (str, optional): The name of the distribution. Default: 'HalfNormal'.
+            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`` .
+        name (str, optional): The name of the distribution. Default: ``'HalfNormal'`` .
 
     Note:
         - `sd` must be greater than zero.

mindspore/nn/probability/distribution/laplace.py

@@ -35,12 +35,12 @@ class Laplace(Distribution):
 
     Args:
         mean (Union[int, float, list, numpy.ndarray, Tensor], optional): The mean of the distribution.
-            If this arg is None, then the mean of the distribution will be passed in runtime. Default: None.
+            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 scale of the distribution.
-            If this arg is None, then the scale 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.
-        name (str, optional): The name of the distribution. Default: 'Laplace'.
+            If this arg is ``None`` , then the scale 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`` .
+        name (str, optional): The name of the distribution. Default: ``'Laplace'`` .
 
     Note:
         - `sd` must be greater than zero.

mindspore/nn/probability/distribution/log_normal.py

@@ -15,6 +15,7 @@
 """LogNormal Distribution"""
 import numpy as np
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.common import dtype as mstype
 import mindspore.nn.probability.bijector as msb
 import mindspore.nn.probability.distribution as msd
@@ -37,12 +38,13 @@ class LogNormal(msd.TransformedDistribution):
     It is constructed as the exponential transformation of a Normal distribution.
 
     Args:
-        loc (int, float, list, numpy.ndarray, Tensor): The mean of the underlying Normal distribution. Default: None.
+        loc (int, float, list, numpy.ndarray, Tensor): The mean of the underlying Normal distribution.
+          Default: ``None`` .
         scale (int, float, list, numpy.ndarray, Tensor): The standard deviation of the underlying
-          Normal distribution. Default: None.
-        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: 'LogNormal'.
+          Normal distribution. Default: ``None`` .
+        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: ``'LogNormal'`` .
 
     Note:
         `scale` must be greater than zero.
@@ -100,7 +102,6 @@ class LogNormal(msd.TransformedDistribution):
         self.expm1 = P.Expm1()
         self.log = log_generic
         self.erf = P.Erf()
-        self.fill = P.Fill()
         self.greater = P.Greater()
         self.select = P.Select()
         self.shape = P.Shape()
@@ -201,7 +202,7 @@ class LogNormal(msd.TransformedDistribution):
         cdf = self.distribution("cdf", inverse_value, mean, sd)
 
         # to increase numerical stability, set cdf = 0 when value <= 0
-        zeros = self.fill(self.dtypeop(cdf), self.shape(cdf), 0.0)
+        zeros = F.fill(self.dtypeop(cdf), self.shape(cdf), 0.0)
 
         return self.select(self.greater(value, 0.), cdf, zeros)
 
@@ -229,8 +230,8 @@ class LogNormal(msd.TransformedDistribution):
             dist (str): The type of the distributions. Should be "LogNormal" in this case.
             loc_b (Tensor): The loc of distribution b.
             scale_b (Tensor): The scale of distribution b.
-            loc_a (Tensor): The loc of distribution a. Default: None.
-            scale_a (Tensor): The scale of distribution a. Default: None.
+            loc_a (Tensor): The loc of distribution a. Default: ``None``.
+            scale_a (Tensor): The scale of distribution a. Default: ``None``.
         """
         check_distribution_name(dist, 'LogNormal')
         return self._entropy(loc_a, scale_a) + self._kl_loss(dist, loc_b, scale_b, loc_a, scale_a)
@@ -243,8 +244,8 @@ class LogNormal(msd.TransformedDistribution):
             dist (str): The type of the distributions. Should be "LogNormal" in this case.
             loc_b (Tensor): The loc of distribution b.
             scale_b (Tensor): The scale of distribution b.
-            loc_a (Tensor): The loc of distribution a. Default: None.
-            scale_a (Tensor): The scale of distribution a. Default: None.
+            loc_a (Tensor): The loc of distribution a. Default: ``None``.
+            scale_a (Tensor): The scale of distribution a. Default: ``None``.
 
         .. math::
             KL(a||b) = 0.5 * (\fract{MEAN(a)}{STD(b)} - \fract{MEAN(b)}{STD(b)}) ^ 2 +

mindspore/nn/probability/distribution/logistic.py

@@ -15,6 +15,7 @@
 """Logistic 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
 from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
@@ -35,11 +36,11 @@ 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.
-        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'.
+        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`` .
+        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'`` .
 
     Note:
         `scale` must be greater than zero.
@@ -153,7 +154,6 @@ class Logistic(Distribution):
         self.dtypeop = P.DType()
         self.exp = exp_generic
         self.expm1 = P.Expm1()
-        self.fill = P.Fill()
         self.less = P.Less()
         self.log = log_generic
         self.log1p = P.Log1p()
@@ -171,7 +171,7 @@ class Logistic(Distribution):
 
         self.threshold = np.log(np.finfo(np.float32).eps) + 1.
         self.tiny = np.finfo(np.float).tiny
-        self.sd_const = np.pi/np.sqrt(3)
+        self.sd_const = np.pi / np.sqrt(3)
 
     def _softplus(self, x):
         too_small = self.less(x, self.threshold)
@@ -179,7 +179,7 @@ class Logistic(Distribution):
         too_small_value = self.exp(x)
         too_large_value = x
         too_small_or_too_large = self.logicalor(too_small, too_large)
-        ones = self.fill(self.dtypeop(x), self.shape(x), 1.0)
+        ones = F.fill(self.dtypeop(x), self.shape(x), 1.0)
         x = self.select(too_small_or_too_large, ones, x)
         y = self.log(self.exp(x) + 1.0)
         return self.select(too_small, too_small_value, self.select(too_large, too_large_value, y))

mindspore/nn/probability/distribution/normal.py

@@ -36,11 +36,12 @@ class Normal(Distribution):
     the standard deviation of the normal distribution respectively.
 
     Args:
-        mean (int, float, list, numpy.ndarray, Tensor): The mean of the Normal distribution. Default: None.
-        sd (int, float, list, numpy.ndarray, Tensor): The standard deviation of the Normal 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: 'Normal'.
+        mean (int, float, list, numpy.ndarray, Tensor): The mean of the Normal distribution. Default: ``None`` .
+        sd (int, float, list, numpy.ndarray, Tensor): The standard deviation of the Normal 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: ``'Normal'`` .
 
     Note:
         `sd` must be greater than zero.

mindspore/nn/probability/distribution/poisson.py

@@ -15,8 +15,8 @@
 """Poisson 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
 from mindspore.common import dtype as mstype
 from .distribution import Distribution
@@ -36,10 +36,10 @@ class Poisson(Distribution):
     where :math:`\lambda` is the rate of the distribution.
 
     Args:
-        rate (list, numpy.ndarray, Tensor): The rate of the Poisson 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: 'Poisson'.
+        rate (list, numpy.ndarray, Tensor): The rate of the Poisson 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: ``'Poisson'`` .
 
     Note:
         `rate` must be strictly greater than 0.
@@ -150,12 +150,11 @@ class Poisson(Distribution):
         self.floor = P.Floor()
         self.dtypeop = P.DType()
         self.shape = P.Shape()
-        self.fill = P.Fill()
         self.less = P.Less()
         self.equal = P.Equal()
         self.select = P.Select()
-        self.lgamma = nn.LGamma()
-        self.igamma = nn.IGamma()
+        self.lgamma = P.Lgamma()
+        self.igamma = P.Igamma()
         self.poisson = C.poisson
 
     @property
@@ -229,8 +228,8 @@ class Poisson(Distribution):
         value = self.cast(value, self.dtype)
         rate = self._check_param_type(rate)
         log_rate = self.log(rate)
-        zeros = self.fill(self.dtypeop(value), self.shape(value), 0.0)
-        inf = self.fill(self.dtypeop(value), self.shape(value), np.inf)
+        zeros = F.fill(self.dtypeop(value), self.shape(value), 0.0)
+        inf = F.fill(self.dtypeop(value), self.shape(value), np.inf)
         safe_x = self.select(self.less(value, zeros), zeros, value)
         y = log_rate * safe_x - self.lgamma(safe_x + 1.)
         comp = self.equal(value, safe_x)
@@ -255,7 +254,7 @@ class Poisson(Distribution):
         value = self._check_value(value, 'value')
         value = self.cast(value, self.dtype)
         rate = self._check_param_type(rate)
-        zeros = self.fill(self.dtypeop(value), self.shape(value), 0.0)
+        zeros = F.fill(self.dtypeop(value), self.shape(value), 0.0)
         comp = self.less(value, zeros)
         safe_x = self.select(comp, zeros, value)
         cdf = 1. - self.igamma(1. + safe_x, rate)

mindspore/nn/probability/distribution/student_t.py

@@ -16,7 +16,6 @@
 from __future__ import absolute_import
 from __future__ import division
 import numpy as np
-import mindspore.nn as nn
 from mindspore.ops import operations as P
 from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
@@ -39,14 +38,14 @@ class StudentT(Distribution):
 
     Args:
         df (Union[int, float, list, numpy.ndarray, Tensor], optional): The degrees of freedom.
-            If this arg is None, then the df of the distribution will be passed in runtime. Default: None.
+            If this arg is ``None`` , then the df of the distribution will be passed in runtime. Default: ``None`` .
         mean (Union[int, float, list, numpy.ndarray, Tensor], optional): The mean of the distribution.
-            If this arg is None, then the df of the distribution will be passed in runtime. Default: None.
+            If this arg is ``None`` , then the df 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.
-            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.
-        name (str, optional): The name of the distribution. Default: 'StudentT'.
+            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`` .
+        name (str, optional): The name of the distribution. Default: ``'StudentT'`` .
 
     Note:
         - `df` must be greater than zero.
@@ -123,7 +122,7 @@ class StudentT(Distribution):
         self.abs = P.Abs()
         self.half = 0.5
         self.half_log_pi = 0.5 * np.log(np.pi)
-        self.lgamma = nn.LGamma()
+        self.lgamma = P.Lgamma()
 
     def _log_prob(self, value, df=None, mean=None, sd=None):
         r"""
@@ -146,5 +145,5 @@ class StudentT(Distribution):
         y = (value - mean) / sd
         log_unnormalized_prob = -0.5 * (df + 1.) * self.log1p(y**2. / df)
         log_normalization = self.log(self.abs(sd)) + 0.5 * self.log(df) + self.half_log_pi + \
-                            self.lgamma(self.half * df) - self.lgamma(self.half * (df + 1.))
+            self.lgamma(self.half * df) - self.lgamma(self.half * (df + 1.))
         return log_unnormalized_prob - log_normalization

mindspore/nn/probability/distribution/transformed_distribution.py

@@ -16,6 +16,7 @@
 import numpy as np
 from mindspore import _checkparam as validator
 from mindspore.ops import operations as P
+from mindspore.ops import functional as F
 from mindspore.common import dtype as mstype
 import mindspore.nn as nn
 from .distribution import Distribution
@@ -35,10 +36,10 @@ class TransformedDistribution(Distribution):
     Args:
         bijector (Bijector): The transformation to perform.
         distribution (Distribution): The original distribution. Must be a float dtype.
-        seed (int): The seed is used in sampling. The global seed is used if it is None. Default: None.
+        seed (int): The seed is used in sampling. The global seed is used if it is None. Default: ``None`` .
           If this seed is given when a TransformedDistribution object is initialized, the object's sampling function
           will use this seed; elsewise, the underlying distribution's seed will be used.
-        name (str): The name of the transformed distribution. Default: 'transformed_distribution'.
+        name (str): The name of the transformed distribution. Default: ``'transformed_distribution'`` .
 
     Note:
         The arguments used to initialize the original distribution cannot be None.
@@ -125,7 +126,6 @@ class TransformedDistribution(Distribution):
         self.cast_base = P.Cast()
         self.equal_base = P.Equal()
         self.select_base = P.Select()
-        self.fill_base = P.Fill()
 
         # broadcast bijector batch_shape and distribution batch_shape
         self._broadcast_shape = self._broadcast_bijector_dist()
@@ -176,9 +176,9 @@ class TransformedDistribution(Distribution):
         """
         if self.batch_shape is None or self.bijector.batch_shape is None:
             return None
-        bijector_shape_tensor = self.fill_base(
+        bijector_shape_tensor = F.fill(
             self.dtype, self.bijector.batch_shape, 0.0)
-        dist_shape_tensor = self.fill_base(self.dtype, self.batch_shape, 0.0)
+        dist_shape_tensor = F.fill(self.dtype, self.batch_shape, 0.0)
         return (bijector_shape_tensor + dist_shape_tensor).shape
 
     def _cdf(self, value, *args, **kwargs):

mindspore/nn/probability/distribution/uniform.py

@@ -14,6 +14,7 @@
 # ============================================================================
 """Uniform Distribution"""
 import numpy as np
+from mindspore.ops import functional as F
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
 from mindspore import _checkparam as Validator
@@ -35,11 +36,11 @@ class Uniform(Distribution):
     where :math:`a, b` are the lower and upper bound respectively.
 
     Args:
-        low (int, float, list, numpy.ndarray, Tensor): The lower bound of the distribution. Default: None.
-        high (int, float, list, numpy.ndarray, Tensor): The upper bound of the distribution. Default: None.
-        seed (int): The seed uses 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: 'Uniform'.
+        low (int, float, list, numpy.ndarray, Tensor): The lower bound of the distribution. Default: ``None`` .
+        high (int, float, list, numpy.ndarray, Tensor): The upper bound of the distribution. Default: ``None`` .
+        seed (int): The seed uses 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: ``'Uniform'`` .
 
     Note:
         `low` must be strictly less than `high`.
@@ -170,7 +171,6 @@ class Uniform(Distribution):
         self.cast = P.Cast()
         self.const = P.ScalarToTensor()
         self.dtypeop = P.DType()
-        self.fill = P.Fill()
         self.less = P.Less()
         self.lessequal = P.LessEqual()
         self.logicaland = P.LogicalAnd()
@@ -287,10 +287,10 @@ class Uniform(Distribution):
         value = self._check_value(value, 'value')
         value = self.cast(value, self.dtype)
         low, high = self._check_param_type(low, high)
-        neg_ones = self.fill(self.dtype, self.shape(value), -1.0)
+        neg_ones = F.fill(self.dtype, self.shape(value), -1.0)
         prob = self.exp(neg_ones * self.log(high - low))
         broadcast_shape = self.shape(prob)
-        zeros = self.fill(self.dtypeop(prob), broadcast_shape, 0.0)
+        zeros = F.fill(self.dtypeop(prob), broadcast_shape, 0.0)
         comp_lo = self.less(value, low)
         comp_hi = self.lessequal(value, high)
         less_than_low = self.select(comp_lo, zeros, prob)
@@ -316,7 +316,7 @@ class Uniform(Distribution):
         kl = self.log(high_b - low_b) - self.log(high_a - low_a)
         comp = self.logicaland(self.lessequal(
             low_b, low_a), self.lessequal(high_a, high_b))
-        inf = self.fill(self.dtypeop(kl), self.shape(kl), np.inf)
+        inf = F.fill(self.dtypeop(kl), self.shape(kl), np.inf)
         return self.select(comp, kl, inf)
 
     def _cdf(self, value, low=None, high=None):
@@ -338,8 +338,8 @@ class Uniform(Distribution):
         low, high = self._check_param_type(low, high)
         prob = (value - low) / (high - low)
         broadcast_shape = self.shape(prob)
-        zeros = self.fill(self.dtypeop(prob), broadcast_shape, 0.0)
-        ones = self.fill(self.dtypeop(prob), broadcast_shape, 1.0)
+        zeros = F.fill(self.dtypeop(prob), broadcast_shape, 0.0)
+        ones = F.fill(self.dtypeop(prob), broadcast_shape, 1.0)
         comp_lo = self.less(value, low)
         comp_hi = self.less(value, high)
         less_than_low = self.select(comp_lo, zeros, prob)

mindspore/nn/reinforcement/tensor_array.py

@@ -32,9 +32,9 @@ class TensorArray(Cell):
     Args:
         dtype (mindspore.dtype): the data type in the TensorArray.
         element_shape (tuple[int]): the shape of each tensor in a TensorArray.
-        dynamic_size (bool): if true, the size of TensorArray can be increased. Default: True.
+        dynamic_size (bool): if ``true`` , the size of TensorArray can be increased. Default: ``True`` .
         size (int): if dynamic_size=False, `size` means the max_size of the TensorArray.
-        name (string): the name of this TensorArray. Default: "TA".
+        name (string): the name of this TensorArray. Default: ``"TA"`` .
 
     Supported Platforms:
         ``GPU`` ``CPU``

mindspore/nn/sparse/sparse.py

@@ -45,7 +45,7 @@ class SparseToDense(Cell):
         TypeError: If `sparse_tensor.shape` is not a tuple.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``CPU``
 
     Examples:
         >>> import mindspore as ms
@@ -90,8 +90,8 @@ class SparseTensorDenseMatmul(Cell):
     The rank of sparse matrix and dense matrix must be equal to `2`.
 
     Args:
-        adjoint_st (bool): If true, sparse tensor is transposed before multiplication. Default: False.
-        adjoint_dt (bool): If true, dense tensor is transposed before multiplication. Default: False.
+        adjoint_st (bool): If ``true`` , sparse tensor is transposed before multiplication. Default: ``False`` .
+        adjoint_dt (bool): If ``true`` , dense tensor is transposed before multiplication. Default: ``False`` .
 
     Inputs:
         - **indices** (Tensor) - A 2-D Tensor, represents the position of the element in the sparse tensor.
@@ -101,15 +101,15 @@ class SparseTensorDenseMatmul(Cell):
         - **sparse_shape** (tuple) - A positive int tuple which specifies the shape of sparse tensor,
           should have 2 elements, represent sparse tensor shape is :math:`(N, C)`.
         - **dense** (Tensor) - A 2-D Tensor, the dtype is same as `values`.
-          If `adjoint_st` is False and `adjoint_dt` is False, the shape must be :math:`(C, M)`.
-          If `adjoint_st` is False and `adjoint_dt` is True, the shape must be :math:`(M, C)`.
-          If `adjoint_st` is True and `adjoint_dt` is False, the shape must be :math:`(N, M)`.
-          If `adjoint_st` is True and `adjoint_dt` is True, the shape must be :math:`(M, N)`.
+          If `adjoint_st` is ``False`` and `adjoint_dt` is ``False`` , the shape must be :math:`(C, M)`.
+          If `adjoint_st` is ``False`` and `adjoint_dt` is ``True`` , the shape must be :math:`(M, C)`.
+          If `adjoint_st` is ``True`` and `adjoint_dt` is ``False`` , the shape must be :math:`(N, M)`.
+          If `adjoint_st` is ``True`` and `adjoint_dt` is ``True`` , the shape must be :math:`(M, N)`.
 
     Outputs:
         Tensor, the dtype is the same as `values`.
-        If `adjoint_st` is False, the shape is :math:`(N, M)`.
-        If `adjoint_st` is True, the shape is :math:`(C, M)`.
+        If `adjoint_st` is ``False`` , the shape is :math:`(N, M)`.
+        If `adjoint_st` is ``True`` , the shape is :math:`(C, M)`.
 
     Raises:
         TypeError: If the type of `adjoint_st` or `adjoint_dt` is not bool, or the dtype of `indices`,