mindspore 2.1.0__cp37-none-any.whl → 2.2.11__cp37-none-any.whl

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:
@@ -339,10 +339,10 @@ def thor(net, learning_rate, damping, momentum, weight_decay=0.0, loss_scale=1.0
         >>> from mindspore import Tensor
         >>>
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+        >>> # 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.1/docs/mindspore/code/mnist.py
+        >>> # 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 = nn.thor(net, learning_rate=temp, damping=temp, momentum=0.9, loss_scale=128, frequency=4)
@@ -424,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
@@ -653,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
 
@@ -739,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()
@@ -1304,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
@@ -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:

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
@@ -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/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
@@ -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/distribution/_utils/custom_ops.py

@@ -15,6 +15,7 @@
 """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
@@ -52,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()
@@ -61,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)

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

@@ -17,6 +17,7 @@ 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
@@ -149,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()
@@ -292,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,
@@ -338,8 +338,8 @@ class Categorical(Distribution):
         # 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:
@@ -359,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))
@@ -394,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)
 
@@ -425,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

@@ -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/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
@@ -185,7 +186,6 @@ 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()
@@ -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)
 

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
@@ -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,6 +15,7 @@
 """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.probability.bijector as msb
@@ -101,7 +102,6 @@ class Gumbel(TransformedDistribution):
         self.const = P.ScalarToTensor()
         self.exp = exp_generic
         self.expm1 = P.Expm1()
-        self.fill = P.Fill()
         self.lgamma = P.Lgamma()
         self.log = log_generic
         self.shape = P.Shape()
@@ -163,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"""
@@ -173,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):
@@ -184,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/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
@@ -101,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()
@@ -202,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)
 

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
@@ -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()
@@ -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/poisson.py

@@ -15,6 +15,7 @@
 """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
 from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
@@ -149,7 +150,6 @@ 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()
@@ -228,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)
@@ -254,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)