mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

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

@@ -15,13 +15,13 @@
 """Utility functions to help distribution class."""
 import numpy as np
 from mindspore import context
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 from mindspore.common.tensor import Tensor
 from mindspore.common.parameter import Parameter
 from mindspore.common import dtype as mstype
-from mindspore.ops import composite as C
 from mindspore.ops import operations as P
-from mindspore.ops.primitive import constexpr, PrimitiveWithInfer, prim_attr_register
+from mindspore.ops.primitive import constexpr, _primexpr, PrimitiveWithInfer, prim_attr_register
+import mindspore.ops as ops
 import mindspore.nn as nn
 
 
@@ -214,7 +214,7 @@ def clamp_probs(probs):
     clamp probs boundary
     """
     eps = P.Eps()(probs)
-    return C.clip_by_value(probs, eps, 1-eps)
+    return ops.clip_by_value(probs, eps, 1-eps)
 
 
 def probs_to_logits(probs, is_binary=False):
@@ -230,48 +230,42 @@ def probs_to_logits(probs, is_binary=False):
     return P.Log()(ps_clamped)
 
 
-@constexpr
+@constexpr(check=False)
 def raise_none_error(name):
     raise TypeError(f"the type {name} must be subclass of Tensor."
                     f" It can not be None since it is not specified during initialization.")
 
 
-@constexpr
-def raise_probs_logits_error():
-    raise TypeError(
-        "Either 'probs' or 'logits' must be specified, but not both.")
-
-
-@constexpr
+@_primexpr
 def raise_broadcast_error(shape_a, shape_b):
     raise ValueError(f"Shape {shape_a} and {shape_b} is not broadcastable.")
 
 
-@constexpr
+@constexpr(check=False)
 def raise_not_impl_error(name):
     raise ValueError(
         f"{name} function must be implemented for non-linear transformation")
 
 
-@constexpr
+@constexpr(check=False)
 def raise_not_implemented_util(func_name, obj, *args, **kwargs):
     raise NotImplementedError(
         f"{func_name} is not implemented for {obj} distribution.")
 
 
-@constexpr
+@constexpr(check=False)
 def raise_type_error(name, cur_type, required_type):
     raise TypeError(
         f"For {name} , the type must be or be subclass of {required_type}, but got {cur_type}")
 
 
-@constexpr
+@constexpr(check=False)
 def raise_not_defined(func_name, obj, *args, **kwargs):
     raise ValueError(
         f"{func_name} is undefined for {obj} distribution.")
 
 
-@constexpr
+@constexpr(check=False)
 def check_distribution_name(name, expected_name):
     if name is None:
         raise ValueError(

mindspore/nn/probability/distribution/bernoulli.py

@@ -16,16 +16,16 @@
 from mindspore.common import dtype as mstype
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from .distribution import Distribution
 from ._utils.utils import check_prob, check_distribution_name, clamp_probs
 from ._utils.custom_ops import exp_generic, log_generic
 
 
 class Bernoulli(Distribution):
-    """
+    r"""
     Bernoulli Distribution.
-    A Bernoulli Distribution is a discrete distribution with the range {0, 1}
+    A Bernoulli Distribution is a discrete distribution with the range :math:`\{0, 1\}`
     and the probability mass function as :math:`P(X = 0) = p, P(X = 1) = 1-p`.
 
     Args:
@@ -149,7 +149,7 @@ class Bernoulli(Distribution):
         self.log = log_generic
         self.squeeze = P.Squeeze(0)
         self.cast = P.Cast()
-        self.const = P.ScalarToArray()
+        self.const = P.ScalarToTensor()
         self.floor = P.Floor()
         self.fill = P.Fill()
         self.less = P.Less()
@@ -324,8 +324,8 @@ class Bernoulli(Distribution):
             sample_shape = (1,)
         else:
             sample_shape = origin_shape
-        l_zero = self.const(0.0)
-        h_one = self.const(1.0)
+        l_zero = self.const(0.0, mstype.float32)
+        h_one = self.const(1.0, mstype.float32)
         sample_uniform = self.uniform(sample_shape, l_zero, h_one, self.seed)
         sample = self.less(sample_uniform, probs1)
         value = self.cast(sample, self.dtype)

mindspore/nn/probability/distribution/beta.py

@@ -17,7 +17,7 @@ import numpy as np
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
 import mindspore.nn as nn
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from .distribution import Distribution
 from ._utils.utils import check_greater_zero, check_distribution_name

mindspore/nn/probability/distribution/categorical.py

@@ -18,19 +18,21 @@ from mindspore import context
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
 from mindspore.ops.functional import stop_gradient
-from mindspore._checkparam import Validator
+from mindspore.ops.operations import _inner_ops as inner
+from mindspore import _checkparam as Validator
+import mindspore.ops as ops
 import mindspore.nn as nn
 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, raise_not_implemented_util
+    check_distribution_name
 from ._utils.custom_ops import exp_generic, log_generic, broadcast_to
 
 
 class Categorical(Distribution):
-    """
+    r"""
     Categorical distribution.
-    A Categorical Distribution is a discrete distribution with the range {1, 2, ..., k}
+    A Categorical Distribution is a discrete distribution with the range :math:`\{1, 2, ..., k\}`
     and the probability mass function as :math:`P(X = i) = p_i, i = 1, ..., k`.
 
     Args:
@@ -140,7 +142,7 @@ class Categorical(Distribution):
         self.argmax = P.ArgMaxWithValue(axis=-1)
         self.broadcast = broadcast_to
         self.cast = P.Cast()
-        self.clip_by_value = C.clip_by_value
+        self.clip_by_value = ops.clip_by_value
         self.concat = P.Concat(-1)
         self.cumsum = P.CumSum()
         self.dtypeop = P.DType()
@@ -149,7 +151,7 @@ class Categorical(Distribution):
         self.fill = P.Fill()
         self.gather = P.GatherNd()
         self.greater = P.Greater()
-        self.issubclass = P.IsSubClass()
+        self.issubclass = inner.IsSubClass()
         self.less = P.Less()
         # when the graph kernel mode is enable
         # use Log directly as akg will handle the corner cases
@@ -236,7 +238,7 @@ class Categorical(Distribution):
         """
         probs = self._check_param_type(probs)
         logits = self.log(probs)
-        return self.squeeze(-self.reduce_sum(logits * probs, -1))
+        return self.squeeze(P.Neg()(self.reduce_sum(logits * probs, -1)))
 
     def _kl_loss(self, dist, probs_b, probs=None):
         """
@@ -403,8 +405,6 @@ class Categorical(Distribution):
         Returns:
             Tensor, shape is shape(probs)[:-1] + sample_shape
         """
-        if self.device_target == 'Ascend':
-            raise_not_implemented_util('On d backend, sample', self.name)
         shape = self.checktuple(shape, 'shape')
         probs = self._check_param_type(probs)
         num_classes = self.shape(probs)[-1]

mindspore/nn/probability/distribution/cauchy.py

@@ -16,7 +16,7 @@
 import numpy as np
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from .distribution import Distribution
 from ._utils.utils import check_greater_zero, check_distribution_name, raise_not_defined
@@ -26,13 +26,13 @@ from ._utils.custom_ops import exp_generic, log_generic, log1p_generic
 class Cauchy(Distribution):
     r"""
     Cauchy distribution.
-    A Cauchy distributio is a continuous distribution with the range :math:`[0, 1]`
+    A Cauchy distributio is a continuous distribution with the range of all real numbers
     and the probability density function:
 
     .. math::
         f(x, a, b) = 1 / \pi b(1 - ((x - a)/b)^2),
 
-    where a and b are loc and scale parameter respectively.
+    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.
@@ -167,7 +167,7 @@ class Cauchy(Distribution):
         # ops needed for the class
         self.atan = P.Atan()
         self.cast = P.Cast()
-        self.const = P.ScalarToArray()
+        self.const = P.ScalarToTensor()
         self.dtypeop = P.DType()
         self.exp = exp_generic
         self.fill = P.Fill()
@@ -308,7 +308,7 @@ class Cauchy(Distribution):
         value = self.cast(value, self.dtype)
         loc, scale = self._check_param_type(loc, scale)
         z = (value - loc) / scale
-        return self.log1p(2. * self.atan(z) / np.pi) - self.log(self.const(2.))
+        return self.log1p(2. * self.atan(z) / np.pi) - self.log(self.const(2., mstype.float32))
 
     def _quantile(self, p, loc=None, scale=None):
         loc, scale = self._check_param_type(loc, scale)
@@ -338,7 +338,7 @@ class Cauchy(Distribution):
         sum_square = self.sq(scale_a + scale_b)
         square_diff = self.sq(loc_a - loc_b)
         return self.log(sum_square + square_diff) - \
-            self.log(self.const(4.0)) - self.log(scale_a) - self.log(scale_b)
+            self.log(self.const(4.0, mstype.float32)) - self.log(scale_a) - self.log(scale_b)
 
     def _cross_entropy(self, dist, loc_b, scale_b, loc_a=None, scale_a=None):
         r"""
@@ -374,8 +374,8 @@ class Cauchy(Distribution):
             sample_shape = (1,)
         else:
             sample_shape = origin_shape
-        l_zero = self.const(0.0)
-        h_one = self.const(1.0)
+        l_zero = self.const(0.0, mstype.float32)
+        h_one = self.const(1.0, mstype.float32)
         sample_uniform = self.uniform(sample_shape, l_zero, h_one, self.seed)
         sample = self._quantile(sample_uniform, loc, scale)
         value = self.cast(sample, self.dtype)

mindspore/nn/probability/distribution/distribution.py

@@ -17,7 +17,8 @@ from mindspore import context
 from mindspore.ops import operations as P
 from mindspore.nn.cell import Cell
 from mindspore.ops.primitive import constexpr
-from mindspore._checkparam import Validator as validator
+from mindspore.ops.operations import _inner_ops as inner
+from mindspore import _checkparam as validator
 from ._utils.utils import raise_none_error, cast_to_tensor, set_param_type, cast_type_for_device,\
     raise_not_implemented_util
 from ._utils.utils import CheckTuple, CheckTensor
@@ -101,7 +102,7 @@ class Distribution(Cell):
         self.device_target = context.get_context('device_target')
         self.checktuple = CheckTuple()
 
-        @constexpr
+        @constexpr(check=False)
         def _check_tensor(x, name):
             CheckTensor()(x, name)
             return x
@@ -112,13 +113,17 @@ class Distribution(Cell):
         # ops needed for the base class
         self.cast_base = P.Cast()
         self.dtype_base = P.DType()
-        self.exp_base = exp_generic
         self.fill_base = P.Fill()
-        self.log_base = log_generic
-        self.sametypeshape_base = P.SameTypeShape()
+        self.sametypeshape_base = inner.SameTypeShape()
         self.sq_base = P.Square()
         self.sqrt_base = P.Sqrt()
         self.shape_base = P.Shape()
+        if self.device_target != "Ascend":
+            self.log_base = P.Log()
+            self.exp_base = P.Exp()
+        else:
+            self.exp_base = exp_generic
+            self.log_base = log_generic
 
     @property
     def name(self):
@@ -427,7 +432,8 @@ class Distribution(Cell):
 
     def prob(self, value, *args, **kwargs):
         """
-        Evaluate the probability (pdf or pmf) at given value.
+        Evaluate the probability (pdf or pmf) at given value. For a discrete distribution,
+        it is a probability mass function, while for a continuous distribution, it is probability density function.
 
         Args:
             value (Tensor): value to be evaluated.

mindspore/nn/probability/distribution/exponential.py

@@ -16,7 +16,7 @@
 import numpy as np
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from .distribution import Distribution
 from ._utils.utils import check_greater_zero, check_distribution_name
@@ -26,7 +26,7 @@ from ._utils.custom_ops import exp_generic, log_generic
 class Exponential(Distribution):
     r"""
     Exponential Distribution.
-    An Exponential distributio is a continuous distribution with the range :math:`[0, 1]`
+    An Exponential distributio is a continuous distribution with the range :math:`[0, \inf)`
     and the probability density function:
 
     .. math::
@@ -159,7 +159,7 @@ class Exponential(Distribution):
         self.log = log_generic
         self.squeeze = P.Squeeze(0)
         self.cast = P.Cast()
-        self.const = P.ScalarToArray()
+        self.const = P.ScalarToTensor()
         self.dtypeop = P.DType()
         self.fill = P.Fill()
         self.less = P.Less()
@@ -340,8 +340,8 @@ class Exponential(Distribution):
             sample_shape = (1,)
         else:
             sample_shape = origin_shape
-        minval = self.const(self.minval)
-        maxval = self.const(1.0)
+        minval = self.const(self.minval, mstype.float32)
+        maxval = self.const(1.0, mstype.float32)
         sample_uniform = self.uniform(sample_shape, minval, maxval, self.seed)
         sample = self.log(sample_uniform) / rate
         value = self.cast(-sample, self.dtype)

mindspore/nn/probability/distribution/gamma.py

@@ -17,7 +17,7 @@ import numpy as np
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
 import mindspore.nn as nn
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from .distribution import Distribution
 from ._utils.utils import check_greater_zero, check_distribution_name
@@ -27,14 +27,14 @@ from ._utils.custom_ops import log_generic
 class Gamma(Distribution):
     r"""
     Gamma distribution.
-    A Gamma distributio is a continuous distribution with the range :math:`[0, 1]`
+    A Gamma distributio is a continuous distribution with the range :math:`(0, \inf)`
     and the probability density function:
 
     .. math::
         f(x, \alpha, \beta) = \beta^\alpha / \Gamma(\alpha) x^{\alpha - 1} \exp(-\beta x).
 
     where :math:`G` is the Gamma function,
-    and :math:`\alpha, \beta` are the concentration and the rate of the distribution respectively.
+    and :math:`\alpha` and :math:`\beta` are the concentration and the rate of the distribution respectively.
 
     Args:
         concentration (int, float, list, numpy.ndarray, Tensor): The concentration,

mindspore/nn/probability/distribution/geometric.py

@@ -15,8 +15,9 @@
 """Geometric Distribution"""
 import numpy as np
 from mindspore.ops import operations as P
+from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops import composite as C
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from .distribution import Distribution
 from ._utils.utils import check_prob, check_distribution_name
@@ -157,11 +158,11 @@ class Geometric(Distribution):
         self.log = log_generic
         self.squeeze = P.Squeeze(0)
         self.cast = P.Cast()
-        self.const = P.ScalarToArray()
+        self.const = P.ScalarToTensor()
         self.dtypeop = P.DType()
         self.fill = P.Fill()
         self.floor = P.Floor()
-        self.issubclass = P.IsSubClass()
+        self.issubclass = inner.IsSubClass()
         self.less = P.Less()
         self.pow = P.Pow()
         self.select = P.Select()
@@ -324,8 +325,8 @@ class Geometric(Distribution):
             sample_shape = (1,)
         else:
             sample_shape = origin_shape
-        minval = self.const(self.minval)
-        maxval = self.const(1.0)
+        minval = self.const(self.minval, mstype.float32)
+        maxval = self.const(1.0, mstype.float32)
         sample_uniform = self.uniform(sample_shape, minval, maxval, self.seed)
         sample = self.floor(self.log(sample_uniform) / self.log(1.0 - probs1))
         value = self.cast(sample, self.dtype)

mindspore/nn/probability/distribution/gumbel.py

@@ -15,7 +15,7 @@
 """Gumbel Distribution"""
 import numpy as np
 from mindspore.ops import operations as P
-from mindspore._checkparam import Validator
+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
@@ -28,13 +28,13 @@ from ._utils.custom_ops import exp_generic, log_generic
 class Gumbel(TransformedDistribution):
     r"""
     Gumbel distribution.
-    A Gumbel distributio is a continuous distribution with the range :math:`[0, 1]`
+    A Gumbel distributio is a continuous distribution with the range of all real numbers
     and the probability density function:
 
     .. math::
         f(x, a, b) = 1 / b \exp(\exp(-(x - a) / b) - x),
 
-    where a and b are loc and scale parameter respectively.
+    where :math:`a, b` are loc and scale parameter respectively.
 
     Args:
         loc (int, float, list, numpy.ndarray, Tensor): The location of Gumbel distribution.
@@ -99,7 +99,7 @@ class Gumbel(TransformedDistribution):
 
         # ops needed for the class
         self.cast = P.Cast()
-        self.const = P.ScalarToArray()
+        self.const = P.ScalarToTensor()
         self.exp = exp_generic
         self.expm1 = P.Expm1()
         self.fill = P.Fill()
@@ -175,7 +175,7 @@ class Gumbel(TransformedDistribution):
         """
         scale = self.scale * \
             self.fill(self.parameter_type, self.broadcast_shape, 1.0)
-        return scale * np.pi / self.sqrt(self.const(6.))
+        return scale * np.pi / self.sqrt(self.const(6., mstype.float32))
 
     def _entropy(self):
         r"""

mindspore/nn/probability/distribution/half_normal.py

@@ -0,0 +1,133 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""HalfNormal Distribution"""
+from __future__ import absolute_import
+from __future__ import division
+import numpy as np
+from mindspore import ops
+from mindspore.ops import operations as P
+from mindspore import _checkparam as Validator
+from mindspore.common import dtype as mstype
+from mindspore.nn.probability.distribution import Distribution
+from mindspore.nn.probability.distribution._utils.utils import check_greater_zero
+
+
+class HalfNormal(Distribution):
+    r"""
+    HalfNormal distribution.
+    A HalfNormal distribution is a continuous distribution with the range :math:`[\mu, \inf)`
+    and the probability density function:
+
+    .. math::
+        f(x, \mu, \sigma) = 1 / \sigma\sqrt{2\pi} \exp(-(x - \mu)^2 / 2\sigma^2).
+
+    where :math:`\mu, \sigma` are the mean and the standard deviation of the half normal distribution respectively.
+
+    Args:
+        mean (Union[int, float, list, numpy.ndarray, Tensor], optional): The mean of the distribution.
+            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'.
+
+    Note:
+        - `sd` must be greater than zero.
+        - `dtype` must be a float type because HalfNormal distributions are continuous.
+        - If the arg `mean` or `sd` is passed in runtime, then it will be used as the parameter value.
+          Otherwise, the value passed in the constructor will be used.
+
+    Raises:
+        ValueError: When sd <= 0.
+        TypeError: When the input `dtype` is not a subclass of float.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> from mindspore.nn.probability.distribution import HalfNormal
+        >>> from mindspore import Tensor
+        >>> # To initialize a HalfNormal distribution of the mean 3.0 and the standard deviation 4.0.
+        >>> n1 = HalfNormal(3.0, 4.0, dtype=mindspore.float32)
+        >>> # A HalfNormal distribution can be initialized without arguments.
+        >>> # In this case, `mean` and `sd` must be passed in through arguments.
+        >>> hn = HalfNormal(dtype=mindspore.float32)
+        >>> # Here are some tensors used below for testing
+        >>> value = Tensor([1.0, 2.0, 3.0], dtype=mindspore.float32)
+        >>> mean_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> sd_a = Tensor([2.0, 2.0, 2.0], dtype=mindspore.float32)
+        >>> mean_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> sd_b = Tensor([1.0, 1.5, 2.5], dtype=mindspore.float32)
+        >>> ans = n1.log_prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # Evaluate with respect to the distribution b.
+        >>> ans = n1.log_prob(value, mean_b, sd_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `mean` and `sd` must be passed in during function calls
+        >>> ans = hn.log_prob(value, mean_a, sd_a)
+        >>> print(ans.shape)
+        (3,)
+    """
+
+    def __init__(self,
+                 mean=None,
+                 sd=None,
+                 seed=None,
+                 dtype=mstype.float32,
+                 name="HalfNormal"):
+        """
+        Constructor of HalfNormal.
+        """
+        param = dict(locals())
+        param['param_dict'] = {'mean': mean, 'sd': sd}
+        valid_dtype = mstype.float_type
+        Validator.check_type_name("dtype", dtype, valid_dtype, type(self).__name__)
+        super(HalfNormal, self).__init__(seed, dtype, name, param)
+
+        self._mean_value = self._add_parameter(mean, 'mean')
+        self._sd_value = self._add_parameter(sd, 'sd')
+        if self._sd_value is not None:
+            check_greater_zero(self._sd_value, "Standard deviation")
+
+        self.exp = P.Exp()
+        self.cast = P.Cast()
+        self.const = ops.scalar_to_tensor(np.sqrt(2. / np.pi))
+        self.sq = P.Square()
+        self.type = dtype
+
+    def _prob(self, value, mean=None, sd=None):
+        r"""
+        Evaluate probability of the value of the HalfNormal distribution.
+
+        Args:
+            value (Tensor): The value to be evaluated.
+            mean (Tensor, optional): The mean of the distribution. Default: self._mean_value.
+            sd (Tensor, optional): The standard deviation the distribution. Default: self._sd_value.
+
+        .. math::
+            P(x) = 1 / \sigma \sqrt{2\pi} \exp(-(x - \mu)^2 / 2\sigma^2)
+        """
+        value = self._check_value(value, 'value')
+        value = self.cast(value, self.dtype)
+        mean, sd = self._check_param_type(mean, sd)
+
+        coeff = self.const / sd
+        pdf = coeff * self.exp(-0.5 * self.sq((value - mean) / sd))
+        return pdf * self.cast(value >= 0, self.type)