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

mindspore/nn/layer/image.py

@@ -64,8 +64,10 @@ class ImageGradients(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> net = nn.ImageGradients()
-        >>> image = Tensor(np.array([[[[1, 2], [3, 4]]]]), dtype=mindspore.int32)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> net = ms.nn.ImageGradients()
+        >>> image = ms.Tensor(np.array([[[[1, 2], [3, 4]]]]), dtype=ms.int32)
         >>> output = net(image)
         >>> print(output)
         (Tensor(shape=[1, 1, 2, 2], dtype=Int32, value=
@@ -81,17 +83,17 @@ class ImageGradients(Cell):
         _check_input_4d(F.shape(images), "images", self.cls_name)
         batch_size, depth, height, width = P.Shape()(images)
         if height == 1:
-            dy = P.Fill()(P.DType()(images), (batch_size, depth, 1, width), 0)
+            dy = F.fill(P.DType()(images), (batch_size, depth, 1, width), 0)
         else:
             dy = images[:, :, 1:, :] - images[:, :, :height - 1, :]
-            dy_last = P.Fill()(P.DType()(images), (batch_size, depth, 1, width), 0)
+            dy_last = F.fill(P.DType()(images), (batch_size, depth, 1, width), 0)
             dy = P.Concat(2)((dy, dy_last))
 
         if width == 1:
-            dx = P.Fill()(P.DType()(images), (batch_size, depth, height, 1), 0)
+            dx = F.fill(P.DType()(images), (batch_size, depth, height, 1), 0)
         else:
             dx = images[:, :, :, 1:] - images[:, :, :, :width - 1]
-            dx_last = P.Fill()(P.DType()(images), (batch_size, depth, height, 1), 0)
+            dx_last = F.fill(P.DType()(images), (batch_size, depth, height, 1), 0)
             dx = P.Concat(3)((dx, dx_last))
         return dy, dx
 
@@ -227,12 +229,12 @@ class SSIM(Cell):
 
     Args:
         max_val (Union[int, float]): The dynamic range of the pixel values (255 for 8-bit grayscale images).
-          Default: 1.0.
+          Default: ``1.0`` .
         filter_size (int): The size of the Gaussian filter. Default: 11. The value must be greater than or equal to 1.
-        filter_sigma (float): The standard deviation of Gaussian kernel. Default: 1.5.
+        filter_sigma (float): The standard deviation of Gaussian kernel. Default: ``1.5`` .
           The value must be greater than 0.
-        k1 (float): The constant used to generate c1 in the luminance comparison function. Default: 0.01.
-        k2 (float): The constant used to generate c2 in the contrast comparison function. Default: 0.03.
+        k1 (float): The constant used to generate c1 in the luminance comparison function. Default: ``0.01`` .
+        k2 (float): The constant used to generate c2 in the contrast comparison function. Default: ``0.03`` .
 
     Inputs:
         - **img1** (Tensor) - The first image batch with format 'NCHW'. It must be the same shape and dtype as img2.
@@ -252,12 +254,11 @@ class SSIM(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore as ms
         >>> import numpy as np
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor
-        >>> net = nn.SSIM()
-        >>> img1 = Tensor(np.ones([1, 3, 16, 16]).astype(np.float32))
-        >>> img2 = Tensor(np.ones([1, 3, 16, 16]).astype(np.float32))
+        >>> net = ms.nn.SSIM()
+        >>> img1 = ms.Tensor(np.ones([1, 3, 16, 16]).astype(np.float32))
+        >>> img2 = ms.Tensor(np.ones([1, 3, 16, 16]).astype(np.float32))
         >>> output = net(img1, img2)
         >>> print(output)
         [1.]
@@ -319,13 +320,13 @@ class MSSSIM(Cell):
 
     Args:
         max_val (Union[int, float]): The dynamic range of the pixel values (255 for 8-bit grayscale images).
-          Default: 1.0.
+          Default: ``1.0`` .
         power_factors (Union[tuple, list]): Iterable of weights for each scale.
           Default: (0.0448, 0.2856, 0.3001, 0.2363, 0.1333). Default values obtained by Wang et al.
-        filter_size (int): The size of the Gaussian filter. Default: 11.
-        filter_sigma (float): The standard deviation of Gaussian kernel. Default: 1.5.
-        k1 (float): The constant used to generate c1 in the luminance comparison function. Default: 0.01.
-        k2 (float): The constant used to generate c2 in the contrast comparison function. Default: 0.03.
+        filter_size (int): The size of the Gaussian filter. Default: ``11`` .
+        filter_sigma (float): The standard deviation of Gaussian kernel. Default: ``1.5`` .
+        k1 (float): The constant used to generate c1 in the luminance comparison function. Default: ``0.01`` .
+        k2 (float): The constant used to generate c2 in the contrast comparison function. Default: ``0.03`` .
 
     Inputs:
         - **img1** (Tensor) - The first image batch with format 'NCHW'. It must be the same shape and dtype as img2.
@@ -348,11 +349,10 @@ class MSSSIM(Cell):
 
     Examples:
         >>> import numpy as np
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor
-        >>> net = nn.MSSSIM(power_factors=(0.033, 0.033, 0.033))
-        >>> img1 = Tensor(np.ones((1, 3, 128, 128)).astype(np.float32))
-        >>> img2 = Tensor(np.ones((1, 3, 128, 128)).astype(np.float32))
+        >>> import mindspore as ms
+        >>> net = ms.nn.MSSSIM(power_factors=(0.033, 0.033, 0.033))
+        >>> img1 = ms.Tensor(np.ones((1, 3, 128, 128)).astype(np.float32))
+        >>> img2 = ms.Tensor(np.ones((1, 3, 128, 128)).astype(np.float32))
         >>> output = net(img1, img2)
         >>> print(output)
         [1.]
@@ -432,7 +432,7 @@ class PSNR(Cell):
 
     Args:
         max_val (Union[int, float]): The dynamic range of the pixel values (255 for 8-bit grayscale images).
-          The value must be greater than 0. Default: 1.0.
+          The value must be greater than 0. Default: ``1.0`` .
 
     Inputs:
         - **img1** (Tensor) - The first image batch with format 'NCHW'. It must be the same shape and dtype as img2.
@@ -450,9 +450,10 @@ class PSNR(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> net = nn.PSNR()
-        >>> img1 = Tensor([[[[1, 2, 3, 4], [1, 2, 3, 4]]]])
-        >>> img2 = Tensor([[[[3, 4, 5, 6], [3, 4, 5, 6]]]])
+        >>> import mindspore as ms
+        >>> net = ms.nn.PSNR()
+        >>> img1 = ms.Tensor([[[[1, 2, 3, 4], [1, 2, 3, 4]]]])
+        >>> img2 = ms.Tensor([[[[3, 4, 5, 6], [3, 4, 5, 6]]]])
         >>> output = net(img1, img2)
         >>> print(output)
         [-6.0206]
@@ -533,8 +534,10 @@ class CentralCrop(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> net = nn.CentralCrop(central_fraction=0.5)
-        >>> image = Tensor(np.random.random((4, 3, 4, 4)), mindspore.float32)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> net = ms.nn.CentralCrop(central_fraction=0.5)
+        >>> image = ms.Tensor(np.random.random((4, 3, 4, 4)), ms.float32)
         >>> output = net(image)
         >>> print(output.shape)
         (4, 3, 2, 2)
@@ -568,7 +571,8 @@ class PixelShuffle(Cell):
     <https://arxiv.org/abs/1609.05158>`_ .
 
     Typically, the input is of shape :math:`(*, C \times r^2, H, W)` , and the output is of shape
-    :math:`(*, C, H \times r, W \times r)`, where r is an upscale factor and * is zero or more batch dimensions.
+    :math:`(*, C, H \times r, W \times r)`,
+    where :math:`r` is an upscale factor and :math:`*` is zero or more batch dimensions.
 
     Note:
         The dimension of input Tensor on Ascend should be less than 7.
@@ -587,15 +591,18 @@ class PixelShuffle(Cell):
     Raises:
         ValueError: If `upscale_factor` is not a positive integer.
         ValueError: If the length of third to last dimension of `input` is not divisible by `upscale_factor` squared.
-        TypeError: If the dimension of `input` is less than 3.
+        ValueError: If the dimension of `input` is less than 3.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
         >>> input_x = np.arange(3 * 2 * 8 * 4 * 4).reshape((3, 2, 8, 4, 4))
-        >>> input_x = mindspore.Tensor(input_x, mindspore.dtype.int32)
-        >>> pixel_shuffle = nn.PixelShuffle(2)
+        >>> input_x = ms.Tensor(input_x, ms.dtype.int32)
+        >>> pixel_shuffle = ms.nn.PixelShuffle(2)
         >>> output = pixel_shuffle(input_x)
         >>> print(output.shape)
         (3, 2, 2, 8, 8)
@@ -615,7 +622,8 @@ class PixelUnshuffle(Cell):
     <https://arxiv.org/abs/1609.05158>`_ .
 
     Typically, the input is of shape :math:`(*, C, H \times r, W \times r)` , and the output is of shape
-    :math:`(*, C \times r^2, H, W)` , where r is a downscale factor and * is zero or more batch dimensions.
+    :math:`(*, C \times r^2, H, W)` ,
+    where :math:`r` is a downscale factor and :math:`*` is zero or more batch dimensions.
 
     Args:
         downscale_factor (int): factor to unshuffle the input, and is a positive integer.
@@ -632,15 +640,18 @@ class PixelUnshuffle(Cell):
     Raises:
         ValueError: If `downscale_factor` is not a positive integer.
         ValueError: If the length of second to last dimension or last dimension is not divisible by `downscale_factor` .
-        TypeError: If the dimension of `input` is less than 3.
+        ValueError: If the dimension of `input` is less than 3.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> pixel_unshuffle = nn.PixelUnshuffle(2)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> pixel_unshuffle = ms.nn.PixelUnshuffle(2)
         >>> input_x = np.arange(8 * 8).reshape((1, 1, 8, 8))
-        >>> input_x = mindspore.Tensor(input_x, mindspore.dtype.int32)
+        >>> input_x = ms.Tensor(input_x, ms.dtype.int32)
         >>> output = pixel_unshuffle(input_x)
         >>> print(output.shape)
         (1, 4, 4, 4)

mindspore/nn/layer/math.py

@@ -66,7 +66,7 @@ class ReduceLogSumExp(Cell):
         ReduceLogSumExp(x) = \log(\sum(e^x))
 
     Args:
-        axis (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: (), reduce all dimensions.
+        axis (Union[int, tuple(int), list(int)]) - The dimensions to reduce. Default: ``()`` , reduce all dimensions.
             Only constant value is allowed.
         keep_dims (bool): If True, keep these reduced dimensions and the length is 1.
             If False, don't keep these dimensions.
@@ -94,8 +94,10 @@ class ReduceLogSumExp(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> op = nn.ReduceLogSumExp(1, keep_dims=True)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
+        >>> op = ms.nn.ReduceLogSumExp(1, keep_dims=True)
         >>> output = op(x)
         >>> print(output.shape)
         (3, 1, 5, 6)
@@ -122,15 +124,15 @@ class ReduceLogSumExp(Cell):
 
 class Range(Cell):
     r"""
-    'nn.Range' is deprecated from version 2.0 and will be removed in a future version,
-    use 'ops.range' instead.
+    The Range class will be deprecated in the future,
+    this function can be replaced by :func:`ops.range`
     """
 
     def __init__(self, start, limit=None, delta=1):
         """Initialize Range."""
         super(Range, self).__init__()
-        logger.warning("'nn.Range' is deprecated from version 2.0 and will be removed in a future version,"
-                       "use 'ops.range' instead.")
+        logger.warning("The Range class will be deprecated in the future,"
+                       "this function can be replaced by :func:`ops.range`")
         if delta == 0:
             raise ValueError(f"For '{self.cls_name}', the 'delta' can not be zero.")
         data = np.arange(start, limit, delta)
@@ -188,8 +190,10 @@ class LGamma(Cell):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> x = Tensor(np.array([2, 3, 4]).astype(np.float32))
-        >>> op = nn.LGamma()
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([2, 3, 4]).astype(np.float32))
+        >>> op = ms.nn.LGamma()
         >>> output = op(x)
         >>> print(output)
         [3.5762787e-07 6.9314754e-01 1.7917603e+00]
@@ -218,9 +222,7 @@ class LGamma(Cell):
         self.log1p = P.Log1p()
         self.abs = P.Abs()
         self.shape = P.Shape()
-        self.dyn_shape = P.TensorShape()
         self.dtype = P.DType()
-        self.fill = P.Fill()
         self.floor = P.Floor()
         self.equal = P.Equal()
         self.greater = P.Greater()
@@ -237,7 +239,7 @@ class LGamma(Cell):
         if F.is_sequence_value_unknown(self.shape(x)):
             infinity = self.ones_like(x) * F.cast(self.inf, input_dtype)
         else:
-            infinity = self.fill(input_dtype, self.shape(x), self.inf)
+            infinity = F.fill(input_dtype, self.shape(x), self.inf)
 
         need_to_reflect = self.less(x, 0.5)
         neg_input = -x
@@ -306,8 +308,10 @@ class DiGamma(Cell):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> x = Tensor(np.array([2, 3, 4]).astype(np.float32))
-        >>> op = nn.DiGamma()
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([2, 3, 4]).astype(np.float32))
+        >>> op = ms.nn.DiGamma()
         >>> output = op(x)
         >>> print(output)
         [0.42278463  0.92278427 1.2561178]
@@ -330,7 +334,6 @@ class DiGamma(Cell):
         self.abs = P.Abs()
         self.shape = P.Shape()
         self.dtype = P.DType()
-        self.fill = P.Fill()
         self.floor = P.Floor()
         self.equal = P.Equal()
         self.less = P.Less()
@@ -351,8 +354,9 @@ class DiGamma(Cell):
             num = 0
             denom = k_base_lanczos_coeff
             for i in range(8):
-                num = num - k_lanczos_coefficients[i] / ((z + i + 1) * (z + i + 1))
-                denom = denom + k_lanczos_coefficients[i] / (z + i + 1)
+                j = z + i + 1
+                num = num - k_lanczos_coefficients[i] / (j * j)
+                denom = denom + k_lanczos_coefficients[i] / j
             return num, denom
 
         num, denom = _calculate_num_denom(z, self.k_base_lanczos_coeff, self.k_lanczos_coefficients)
@@ -365,7 +369,7 @@ class DiGamma(Cell):
         reduced_input = x + self.abs(self.floor(x + 0.5))
         reflection = y - self.pi * self.cos(self.pi * reduced_input) / self.sin(self.pi * reduced_input)
         real_result = self.select(need_to_reflect, reflection, y)
-        nan = self.fill(self.dtype(x), self.shape(x), np.nan)
+        nan = F.fill(self.dtype(x), self.shape(x), np.nan)
 
         return self.select(self.logicaland(self.less(x, 0), self.equal(x, self.floor(x))),
                            nan, real_result)
@@ -385,7 +389,6 @@ def _igamma_series(ax, x, a, enabled):
 
     logicaland = P.LogicalAnd()
     greater = P.Greater()
-    fill = P.Fill()
     shape = P.Shape()
     dtype = P.DType()
     select = P.Select()
@@ -418,8 +421,8 @@ def _igamma_series(ax, x, a, enabled):
                 select(enabled, x, vals[4]), select(enabled, dc_da, vals[5]),
                 select(enabled, dans_da, vals[6]))
 
-    ones = fill(dtype(a), shape(a), 1)
-    zeros = fill(dtype(a), shape(a), 0)
+    ones = F.fill(dtype(a), shape(a), 1)
+    zeros = F.fill(dtype(a), shape(a), 0)
     vals = (enabled, a, ones, ones, x, zeros, zeros)
 
     vals = _while_helper_func(cond, body, vals)
@@ -435,7 +438,6 @@ def _igammac_continued_fraction(ax, x, a, enabled):
     greater = P.Greater()
     less = P.Less()
     notequal = P.NotEqual()
-    fill = P.Fill()
     shape = P.Shape()
     dtype = P.DType()
     select = P.Select()
@@ -476,7 +478,7 @@ def _igammac_continued_fraction(ax, x, a, enabled):
         qk_is_nonzero = notequal(qk, 0)
         r = pk / qk
 
-        t = select(qk_is_nonzero, abs_x((ans - r) / r), fill(dtype(t), shape(t), 1))
+        t = select(qk_is_nonzero, abs_x((ans - r) / r), F.fill(dtype(t), shape(t), 1))
         ans = select(qk_is_nonzero, r, ans)
 
         dpk_da = dpkm1_da * z - pkm1 - dpkm2_da * yc + pkm2 * c
@@ -484,7 +486,7 @@ def _igammac_continued_fraction(ax, x, a, enabled):
         dans_da_new = select(qk_is_nonzero, (dpk_da - ans * dqk_da) / qk, dans_da)
         grad_conditional = select(qk_is_nonzero,
                                   abs_x(dans_da_new - dans_da),
-                                  fill(dtype(dans_da), shape(dans_da), 1))
+                                  F.fill(dtype(dans_da), shape(dans_da), 1))
 
         pkm2 = pkm1
         pkm1 = pk
@@ -519,16 +521,16 @@ def _igammac_continued_fraction(ax, x, a, enabled):
 
     y = 1 - a
     z = x + y + 1
-    c = fill(dtype(x), shape(x), 0)
-    pkm2 = fill(dtype(x), shape(x), 1)
+    c = F.fill(dtype(x), shape(x), 0)
+    pkm2 = F.fill(dtype(x), shape(x), 1)
     qkm2 = x
     pkm1 = x + 1
     qkm1 = z * x
     ans = pkm1 / qkm1
-    t = fill(dtype(x), shape(x), 1)
-    dpkm2_da = fill(dtype(x), shape(x), 0)
-    dqkm2_da = fill(dtype(x), shape(x), 0)
-    dpkm1_da = fill(dtype(x), shape(x), 0)
+    t = F.fill(dtype(x), shape(x), 1)
+    dpkm2_da = F.fill(dtype(x), shape(x), 0)
+    dqkm2_da = F.fill(dtype(x), shape(x), 0)
+    dpkm1_da = F.fill(dtype(x), shape(x), 0)
     dqkm1_da = -x
     dans_da = (dpkm1_da - ans * dqkm1_da) / qkm1
     vals = (enabled, ans, t, y, z, c, pkm1, qkm1, pkm2, qkm2, dpkm2_da, dqkm2_da, dpkm1_da, dqkm1_da, dans_da)
@@ -571,9 +573,11 @@ class IGamma(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> a = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
-        >>> x = Tensor(np.array([2.0, 3.0, 4.0, 5.0]).astype(np.float32))
-        >>> igamma = nn.IGamma()
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> a = ms.Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
+        >>> x = ms.Tensor(np.array([2.0, 3.0, 4.0, 5.0]).astype(np.float32))
+        >>> igamma = ms.nn.IGamma()
         >>> output = igamma(a, x)
         >>> print (output)
         [0.593994  0.35276785  0.21486944  0.13337152]
@@ -598,7 +602,6 @@ class IGamma(Cell):
         self.exp = P.Exp()
         self.select = P.Select()
         self.zeroslike = P.ZerosLike()
-        self.fill = P.Fill()
         self.shape = P.Shape()
         self.dtype = P.DType()
         self.lgamma = LGamma()
@@ -625,7 +628,7 @@ class IGamma(Cell):
                              1 - _igammac_continued_fraction(ax, x, a, self.logicaland(enabled, use_igammac)),
                              _igamma_series(ax, x, a, self.logicaland(enabled, self.logicalnot(use_igammac))))
         output = self.select(x_is_zero, self.zeroslike(output), output)
-        output = self.select(domain_error, self.fill(self.dtype(a), self.shape(a), np.nan), output)
+        output = self.select(domain_error, F.fill(self.dtype(a), self.shape(a), np.nan), output)
         return output
 
 
@@ -660,9 +663,11 @@ class LBeta(Cell):
         ``Ascend`` ``GPU``
 
     Examples:
-        >>> x = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
-        >>> y = Tensor(np.array([2.0, 3.0, 14.0, 15.0]).astype(np.float32))
-        >>> lbeta = nn.LBeta()
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
+        >>> y = ms.Tensor(np.array([2.0, 3.0, 14.0, 15.0]).astype(np.float32))
+        >>> lbeta = ms.nn.LBeta()
         >>> output = lbeta(y, x)
         >>> print(output)
         [-1.7917596  -4.094345  -12.000229  -14.754799]
@@ -887,8 +892,8 @@ class CosineSimilarity(Cell):
     the lower bound of :math:`\parallel \textbf{x} \parallel \parallel \textbf{y} \parallel` is set to `eps`.
 
     Args:
-        dim (int, optional): Dimension. Default: 1.
-        eps (float, optional): Small value. Default: 1e-08.
+        dim (int, optional): Dimension. Default: ``1`` .
+        eps (float, optional): Small value. Default: ``1e-08`` .
 
     Inputs:
         - **x1** (Tensor) - The first tensor :math:`\textbf{x}`.
@@ -905,9 +910,11 @@ class CosineSimilarity(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> x1 = Tensor([[1.0, 3.0, 4.0, 7.0], [2.0, 4.0, 2.0, 5.0], [3.0, 1.0, 5.0, 8.0]])
-        >>> x2 = Tensor([[2.0, 4.0, 2.0, 5.0], [3.0, 1.0, 5.0, 8.0], [1.0, 3.0, 4.0, 7.0]])
-        >>> func = nn.layer.CosineSimilarity()
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x1 = ms.Tensor([[1.0, 3.0, 4.0, 7.0], [2.0, 4.0, 2.0, 5.0], [3.0, 1.0, 5.0, 8.0]])
+        >>> x2 = ms.Tensor([[2.0, 4.0, 2.0, 5.0], [3.0, 1.0, 5.0, 8.0], [1.0, 3.0, 4.0, 7.0]])
+        >>> func = ms.nn.layer.CosineSimilarity()
         >>> out = func(x1, x2)
         >>> print(out.asnumpy())
         [0.9402562 0.8614609 0.9516245]
@@ -938,15 +945,15 @@ class CosineSimilarity(Cell):
 
 class Moments(Cell):
     """
-    'nn.Moments' is deprecated from version 2.0 and will be removed in a future version,
-    use 'ops.var_mean' instead.
+    The Moments class will be deprecated in the future,
+    this function can be replaced by :func:`ops.var_mean`
     """
 
     def __init__(self, axis=None, keep_dims=None):
         """Initialize Moments."""
         super(Moments, self).__init__()
-        logger.warning("'nn.Moments' is deprecated from version 2.0 and will be removed in a future version,"
-                       "use 'ops.var_mean' instead.")
+        logger.warning("The Moments class will be deprecated in the future,"
+                       "this function can be replaced by :func:`ops.var_mean`")
         if axis is None:
             axis = ()
         if isinstance(axis, tuple):
@@ -996,8 +1003,10 @@ class MatInverse(Cell):
         ``GPU``
 
     Examples:
-        >>> x = Tensor(np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]]).astype(np.float32))
-        >>> op = nn.MatInverse()
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]]).astype(np.float32))
+        >>> op = ms.nn.MatInverse()
         >>> output = op(x)
         >>> print(output)
         [[49.36112  -13.555558  2.1111116]
@@ -1038,8 +1047,10 @@ class MatDet(Cell):
         ``GPU``
 
     Examples:
-        >>> x = Tensor(np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]]).astype(np.float32))
-        >>> op = nn.MatDet()
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]]).astype(np.float32))
+        >>> op = ms.nn.MatDet()
         >>> output = op(x)
         >>> print(output)
         35.999996