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

mindspore/nn/probability/distribution/laplace.py

@@ -0,0 +1,128 @@
+# 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.
+# ============================================================================
+"""Laplace Distribution"""
+from __future__ import absolute_import
+from __future__ import division
+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 Laplace(Distribution):
+    r"""
+    Laplace distribution.
+    A Laplace distribution is a continuous distribution with the range :math:`(-\inf, \inf)`
+    and the probability density function:
+
+    .. math::
+        f(x, \mu, b) = 1 / (2 * b) * \exp(-abs(x - \mu) / b).
+
+    where :math:`\mu, b` are the mean and the scale of the laplace 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 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'.
+
+    Note:
+        - `sd` must be greater than zero.
+        - `dtype` must be a float type because Laplace 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:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import mindspore.nn as nn
+        >>> from mindspore.nn.probability.distribution import Laplace
+        >>> from mindspore import Tensor
+        >>> # To initialize a Laplace distribution of the mean 3.0 and the scale 4.0.
+        >>> n1 = Laplace(3.0, 4.0, dtype=mindspore.float32)
+        >>> # A Laplace distribution can be initialized without arguments.
+        >>> # In this case, `mean` and `sd` must be passed in through arguments.
+        >>> n2 = Laplace(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.0], 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 = n2.log_prob(value, mean_a, sd_a)
+        >>> print(ans.shape)
+        (3,)
+    """
+
+    def __init__(self,
+                 mean=None,
+                 sd=None,
+                 seed=None,
+                 dtype=mstype.float32,
+                 name="Laplace"):
+        """
+        Constructor of Laplace.
+        """
+        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(Laplace, 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.log = P.Log()
+        self.cast = P.Cast()
+        self.abs = P.Abs()
+
+    def _log_prob(self, value, mean=None, sd=None):
+        r"""
+        Evaluate log probability of the laplace 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 scale the distribution. Default: self._sd_value.
+
+        .. math::
+            L(x) = -1* \abs{\frac{x - \mu}{\sigma}} - \log(2. * \sigma))
+        """
+        value = self._check_value(value, 'value')
+        value = self.cast(value, self.dtype)
+        mean, sd = self._check_param_type(mean, sd)
+
+        pdf = -1.0 * (self.abs((value - mean) / sd)) - self.log(2. * sd)
+        return pdf

mindspore/nn/probability/distribution/log_normal.py

@@ -99,7 +99,6 @@ class LogNormal(msd.TransformedDistribution):
         self.exp = exp_generic
         self.expm1 = P.Expm1()
         self.log = log_generic
-        self.const = P.ScalarToArray()
         self.erf = P.Erf()
         self.fill = P.Fill()
         self.greater = P.Greater()

mindspore/nn/probability/distribution/logistic.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
@@ -32,7 +32,7 @@ class Logistic(Distribution):
     .. 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 (float, list, numpy.ndarray, Tensor): The location of the Logistic distribution. Default: None.
@@ -149,7 +149,6 @@ class Logistic(Distribution):
 
         # ops needed for the class
         self.cast = P.Cast()
-        self.const = P.ScalarToArray()
         self.consttensor = P.ScalarToTensor()
         self.dtypeop = P.DType()
         self.exp = exp_generic
@@ -369,8 +368,8 @@ class Logistic(Distribution):
             sample_shape = (1,)
         else:
             sample_shape = origin_shape
-        l_zero = self.const(self.tiny)
-        h_one = self.const(1.0)
+        l_zero = self.consttensor(self.tiny, mstype.float32)
+        h_one = self.consttensor(1.0, mstype.float32)
         sample_uniform = self.uniform(sample_shape, l_zero, h_one, self.seed)
         sample = self.log(sample_uniform) - self.log1p(self.neg(sample_uniform))
         sample = sample * scale + loc

mindspore/nn/probability/distribution/normal.py

@@ -14,20 +14,19 @@
 # ============================================================================
 """Normal Distribution"""
 import numpy as np
-from mindspore import context
 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 mindspore.common import Tensor
 from .distribution import Distribution
 from ._utils.utils import check_greater_zero, check_distribution_name
-from ._utils.custom_ops import exp_generic, log_generic
 
 
 class Normal(Distribution):
     r"""
     Normal distribution.
-    A Normal distributio is a continuous distribution with the range :math:`(-\inf, \inf)`
+    A Normal distribution is a continuous distribution with the range :math:`(-\inf, \inf)`
     and the probability density function:
 
     .. math::
@@ -166,18 +165,17 @@ class Normal(Distribution):
             check_greater_zero(self._sd_value, "Standard deviation")
 
         # ops needed for the class
-        self.exp = exp_generic
+        self.exp = self.exp_base
+        self.log = self.log_base
         self.expm1 = P.Expm1()
-        # 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.erf = P.Erf()
         self.squeeze = P.Squeeze(0)
         self.cast = P.Cast()
-        self.const = P.ScalarToArray()
+        self.const = P.ScalarToTensor()
         self.shape = P.Shape()
         self.sq = P.Square()
         self.sqrt = P.Sqrt()
+        self.coff = Tensor(-0.5 * np.log(2. * np.pi), dtype=dtype)
 
     def extend_repr(self):
         """Display instance object as string."""
@@ -231,7 +229,7 @@ class Normal(Distribution):
             H(X) = \log(\sqrt(numpy.e * 2. * numpy.pi * \sq(\sigma)))
         """
         mean, sd = self._check_param_type(mean, sd)
-        return self.log(self.sqrt(self.const(np.e * 2. * np.pi))) + self.log(sd)
+        return self.log(self.sqrt(self.const(np.e * 2. * np.pi, mstype.float32))) + self.log(sd)
 
     def _cross_entropy(self, dist, mean_b, sd_b, mean=None, sd=None):
         r"""
@@ -262,10 +260,8 @@ class Normal(Distribution):
         value = self._check_value(value, 'value')
         value = self.cast(value, self.dtype)
         mean, sd = self._check_param_type(mean, sd)
-        unnormalized_log_prob = -1. * \
-            (self.sq(value - mean)) / (2. * self.sq(sd))
-        neg_normalization = -1. * \
-            self.log(self.const(2. * np.pi)) / 2. - self.log(sd)
+        unnormalized_log_prob = -0.5 * (self.sq((value - mean) / sd))
+        neg_normalization = self.coff - self.log(sd)
         return unnormalized_log_prob + neg_normalization
 
     def _cdf(self, value, mean=None, sd=None):
@@ -283,7 +279,7 @@ class Normal(Distribution):
         value = self._check_value(value, 'value')
         value = self.cast(value, self.dtype)
         mean, sd = self._check_param_type(mean, sd)
-        sqrt2 = self.sqrt(self.const(2.0))
+        sqrt2 = self.sqrt(self.const(2.0, mstype.float32))
         adjusted = (value - mean) / (sd * sqrt2)
         return 0.5 * (1.0 + self.erf(adjusted))
 

mindspore/nn/probability/distribution/poisson.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
@@ -28,7 +28,11 @@ class Poisson(Distribution):
     r"""
     Poisson Distribution.
     A Poisson Distribution is a discrete distribution with the range as the non-negative integers,
-    and the probability mass function as :math:`P(X = k) = \lambda^k \exp(-\lambda) / k!, k = 1, 2, ...`,
+    and the probability mass function as
+
+    .. math::
+        P(X = k) = \lambda^k \exp(-\lambda) / k!, k = 1, 2, ...
+
     where :math:`\lambda` is the rate of the distribution.
 
     Args:

mindspore/nn/probability/distribution/student_t.py

@@ -0,0 +1,150 @@
+# 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.
+# ============================================================================
+"""StudentT Distribution"""
+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
+from mindspore.nn.probability.distribution import Distribution
+from mindspore.nn.probability.distribution._utils.utils import check_greater_zero
+
+
+class StudentT(Distribution):
+    r"""
+    StudentT distribution.
+    A StudentT distribution is a continuous distribution with the range :math:`(-\inf, \inf)`
+    and the probability density function:
+
+    .. math::
+        f(x, \nu, \mu, \sigma) = (1 + y^2 / \nu)^{(-0.5*(\nu + 1))} / Z
+
+    where :math:`y = (x - \mu)/ \sigma`,
+    :math:`Z = abs(\sigma) * \sqrt{(\nu * \pi)} * \Gamma(0.5 * \nu) / \Gamma(0.5 * (\nu + 1))`,
+    :math:`\nu, \mu, \sigma` are the degrees of freedom , mean and sd of the laplace distribution respectively.
+
+    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.
+        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.
+        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'.
+
+    Note:
+        - `df` must be greater than zero.
+        - `sd` must be greater than zero.
+        - `dtype` must be a float type because StudentT distributions are continuous.
+        - If the arg `df`, `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 df <= 0.
+        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
+        >>> import mindspore.nn.probability.distribution as msd
+        >>> from mindspore import Tensor
+        >>> # To initialize a StudentT distribution of the df 2.0, the mean 3.0 and the standard deviation 4.0.
+        >>> n1 = msd.StudentT(2.0, 3.0, 4.0, dtype=mindspore.float32)
+        >>> # A StudentT distribution can be initialized without arguments.
+        >>> # In this case, `df`, `mean` and `sd` must be passed in through arguments.
+        >>> n2 = msd.StudentT(dtype=mindspore.float32)
+        >>> # Here are some tensors used below for testing
+        >>> value = Tensor([1.0, 2.0, 3.0], dtype=mindspore.float32)
+        >>> df_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> mean_a = Tensor([2.0], dtype=mindspore.float32)
+        >>> sd_a = Tensor([2.0, 2.0, 2.0], dtype=mindspore.float32)
+        >>> df_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> mean_b = Tensor([1.0], dtype=mindspore.float32)
+        >>> sd_b = Tensor([1.0, 1.5, 2.0], dtype=mindspore.float32)
+        >>> ans = n1.log_prob(value)
+        >>> print(ans.shape)
+        (3,)
+        >>> # Evaluate with respect to the distribution b.
+        >>> ans = n1.log_prob(value, df_b, mean_b, sd_b)
+        >>> print(ans.shape)
+        (3,)
+        >>> # `mean` and `sd` must be passed in during function calls
+        >>> ans = n2.log_prob(value, df_a, mean_a, sd_a)
+        >>> print(ans.shape)
+        (3,)
+    """
+
+    def __init__(self,
+                 df=None,
+                 mean=None,
+                 sd=None,
+                 seed=None,
+                 dtype=mstype.float32,
+                 name="StudentT"):
+        """
+        Constructor of StudentT.
+        """
+        param = dict(locals())
+        param['param_dict'] = {'df': df, 'mean': mean, 'sd': sd}
+        valid_dtype = mstype.float_type
+        Validator.check_type_name("dtype", dtype, valid_dtype, type(self).__name__)
+        super(StudentT, self).__init__(seed, dtype, name, param)
+
+        self._df_value = self._add_parameter(df, 'df')
+        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")
+        if self._df_value is not None:
+            check_greater_zero(self._df_value, "Degrees of freedom")
+        self.log1p = P.Log1p()
+        self.log = P.Log()
+        self.cast = P.Cast()
+        self.abs = P.Abs()
+        self.half = 0.5
+        self.half_log_pi = 0.5 * np.log(np.pi)
+        self.lgamma = nn.LGamma()
+
+    def _log_prob(self, value, df=None, mean=None, sd=None):
+        r"""
+        Evaluate log probability of the value of the StudentT distribution.
+
+        Args:
+            value (Tensor): The value to be evaluated.
+            df (Tensor, optional): The degrees of freedom of the distribution. Default: self._df_value.
+            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::
+            L(x) = -0.5 * (\nu + 1.) * \log((x - \mu) / \sigma + 1.)) + \log(\sqrt(\pi * \mu * \sigma^2))
+                + log(\Gamma(\nu / 2.)) - log(\Gamma((\nu + 1.) / 2.))
+        """
+        value = self._check_value(value, 'value')
+        value = self.cast(value, self.dtype)
+        df, mean, sd = self._check_param_type(df, mean, sd)
+
+        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.))
+        return log_unnormalized_prob - log_normalization

mindspore/nn/probability/distribution/transformed_distribution.py

@@ -14,7 +14,7 @@
 # ============================================================================
 """Transformed Distribution"""
 import numpy as np
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 from mindspore.ops import operations as P
 from mindspore.common import dtype as mstype
 import mindspore.nn as nn
@@ -28,9 +28,9 @@ class TransformedDistribution(Distribution):
     Transformed Distribution.
     This class contains a bijector and a distribution and transforms the original distribution
     to a new distribution through the operation defined by the bijector.
-    If X is an random variable following the underying distribution,
-    and g(x) is a function represented by the bijector,
-    then Y = g(X) is a random variable following the transformed distribution.
+    If :math:`X` is an random variable following the underying distribution,
+    and :math:`g(x)` is a function represented by the bijector,
+    then :math:`Y = g(X)` is a random variable following the transformed distribution.
 
     Args:
         bijector (Bijector): The transformation to perform.

mindspore/nn/probability/distribution/uniform.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, check_distribution_name
@@ -32,7 +32,7 @@ class Uniform(Distribution):
     .. math::
         f(x, a, b) = 1 / (b - a),
 
-    where a and b are the lower and upper bound respectively.
+    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.
@@ -168,7 +168,7 @@ class Uniform(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()
@@ -365,8 +365,8 @@ class Uniform(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 = (high - low) * sample_uniform + low
         value = self.cast(sample, self.dtype)

mindspore/nn/reinforcement/_tensors_queue.py

@@ -19,7 +19,7 @@ from __future__ import absolute_import
 
 from mindspore.nn.cell import Cell
 from mindspore.ops.operations import _rl_inner_ops as rl_ops
-from mindspore._checkparam import Rel, Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 
 
@@ -59,9 +59,9 @@ class TensorsQueue(Cell):
         """Initialize TensorsQueue"""
         super(TensorsQueue, self).__init__()
         Validator.check_subclass("dtype", dtype, mstype.number_type + (mstype.bool_,), self.cls_name)
-        Validator.check_int(size, 0, Rel.GE, "size", self.cls_name)
+        Validator.check_int(size, 0, Validator.GE, "size", self.cls_name)
         elements_num = len(shapes)
-        Validator.check_int(elements_num, 1, Rel.GE, "len(shapes)", self.cls_name)
+        Validator.check_int(elements_num, 1, Validator.GE, "len(shapes)", self.cls_name)
         self.handle_ = rl_ops.TensorsQueueCreate(dtype, shapes, size, name)()
         self.tensors_q_put = rl_ops.TensorsQueuePut(dtype, shapes)
         self.tensors_q_get = rl_ops.TensorsQueueGet(dtype, shapes)

mindspore/nn/reinforcement/tensor_array.py

@@ -19,7 +19,7 @@ from __future__ import absolute_import
 
 from mindspore.nn.cell import Cell
 from mindspore.ops.operations import _tensor_array as ta
-from mindspore._checkparam import Rel, Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 
 
@@ -62,7 +62,7 @@ class TensorArray(Cell):
         """Initialize TensorArray"""
         super(TensorArray, self).__init__()
         Validator.check_subclass("dtype", dtype, mstype.number_type + (mstype.bool_,), self.cls_name)
-        Validator.check_int(size, 0, Rel.GE, "size", self.cls_name)
+        Validator.check_int(size, 0, Validator.GE, "size", self.cls_name)
         self.handle_ = ta.TensorArray(dtype, element_shape, dynamic_size, size, name)()
         self.tensor_array_write = ta.TensorArrayWrite()
         self.tensor_array_read = ta.TensorArrayRead(dtype, element_shape)

mindspore/nn/sparse/sparse.py

@@ -15,6 +15,7 @@
 """Sparse related tools."""
 from __future__ import absolute_import
 
+from mindspore import log as logger
 from mindspore.ops import operations as P
 from mindspore.nn.cell import Cell
 
@@ -28,6 +29,10 @@ class SparseToDense(Cell):
     Separate indexes, values and dense shape tensors can be wrapped in a Sparse Tensor object
     before :class:`mindspore.ops.SparseToDense` is called.
 
+    Note:
+        'nn.SparseToDense' is deprecated from version 2.0, and will be removed in a future version, please use
+        COOTensor.to_dense() instead.
+
     Inputs:
         - **coo_tensor** (:class:`mindspore.COOTensor`) - the sparse COOTensor to convert.
 
@@ -68,6 +73,8 @@ class SparseToDense(Cell):
 
     def __init__(self):
         """Initialize SparseToDense."""
+        logger.warning("'nn.SparseToDense' is deprecated from version 2.0 and will be removed in a future version. " +
+                       "Please use 'COOTensor.to_dense()' instead.")
         super(SparseToDense, self).__init__()
         self.sparse_to_dense = P.SparseToDense()
 
@@ -111,7 +118,7 @@ class SparseTensorDenseMatmul(Cell):
             and shape of `dense` don't meet the parameter description.
 
     Supported Platforms:
-        ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore as ms