mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/nn/layer/image.py

@@ -25,8 +25,8 @@ from mindspore.common.tensor import Tensor
 from mindspore.ops import operations as P
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops import functional as F
-from mindspore.ops.primitive import constexpr
-from mindspore._checkparam import Rel, Validator as validator
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore import _checkparam as validator
 from mindspore.nn.layer.conv import Conv2d
 from mindspore.nn.layer.container import CellList
 from mindspore.nn.layer.pooling import AvgPool2d
@@ -78,8 +78,7 @@ class ImageGradients(Cell):
         super(ImageGradients, self).__init__()
 
     def construct(self, images):
-        check = _check_input_4d(F.shape(images), "images", self.cls_name)
-        images = F.depend(images, check)
+        _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)
@@ -120,19 +119,18 @@ def _get_dtype_max(dtype):
     return dtype_max
 
 
-@constexpr
+@_primexpr
 def _check_input_4d(input_shape, param_name, func_name):
     if len(input_shape) != 4:
         raise ValueError(f"For '{func_name}', the dimension of '{param_name}' must be 4d, "
                          f"but got {len(input_shape)}.")
-    return True
 
 
-@constexpr
+@_primexpr
 def _check_input_filter_size(input_shape, param_name, filter_size, func_name):
     _check_input_4d(input_shape, param_name, func_name)
-    validator.check(param_name + " shape[2]", input_shape[2], "filter_size", filter_size, Rel.GE, func_name)
-    validator.check(param_name + " shape[3]", input_shape[3], "filter_size", filter_size, Rel.GE, func_name)
+    validator.check(param_name + " shape[2]", input_shape[2], "filter_size", filter_size, validator.GE, func_name)
+    validator.check(param_name + " shape[3]", input_shape[3], "filter_size", filter_size, validator.GE, func_name)
 
 
 @constexpr
@@ -267,9 +265,9 @@ class SSIM(Cell):
     def __init__(self, max_val=1.0, filter_size=11, filter_sigma=1.5, k1=0.01, k2=0.03):
         super(SSIM, self).__init__()
         validator.check_value_type('max_val', max_val, [int, float], self.cls_name)
-        validator.check_number('max_val', max_val, 0.0, Rel.GT, self.cls_name)
+        validator.check_number('max_val', max_val, 0.0, validator.GT, self.cls_name)
         self.max_val = max_val
-        self.filter_size = validator.check_int(filter_size, 1, Rel.GE, 'filter_size', self.cls_name)
+        self.filter_size = validator.check_int(filter_size, 1, validator.GE, 'filter_size', self.cls_name)
         self.filter_sigma = validator.check_positive_float(filter_sigma, 'filter_sigma', self.cls_name)
         self.k1 = validator.check_value_type('k1', k1, [float], self.cls_name)
         self.k2 = validator.check_value_type('k2', k2, [float], self.cls_name)
@@ -363,10 +361,10 @@ class MSSSIM(Cell):
                  filter_sigma=1.5, k1=0.01, k2=0.03):
         super(MSSSIM, self).__init__()
         validator.check_value_type('max_val', max_val, [int, float], self.cls_name)
-        validator.check_number('max_val', max_val, 0.0, Rel.GT, self.cls_name)
+        validator.check_number('max_val', max_val, 0.0, validator.GT, self.cls_name)
         self.max_val = max_val
         validator.check_value_type('power_factors', power_factors, [tuple, list], self.cls_name)
-        self.filter_size = validator.check_int(filter_size, 1, Rel.GE, 'filter_size', self.cls_name)
+        self.filter_size = validator.check_int(filter_size, 1, validator.GE, 'filter_size', self.cls_name)
         self.filter_sigma = validator.check_positive_float(filter_sigma, 'filter_sigma', self.cls_name)
         self.k1 = validator.check_value_type('k1', k1, [float], self.cls_name)
         self.k2 = validator.check_value_type('k2', k2, [float], self.cls_name)
@@ -462,7 +460,7 @@ class PSNR(Cell):
     def __init__(self, max_val=1.0):
         super(PSNR, self).__init__()
         validator.check_value_type('max_val', max_val, [int, float], self.cls_name)
-        validator.check_number('max_val', max_val, 0.0, Rel.GT, self.cls_name)
+        validator.check_number('max_val', max_val, 0.0, validator.GT, self.cls_name)
         self.max_val = max_val
 
     def construct(self, img1, img2):
@@ -481,22 +479,26 @@ class PSNR(Cell):
         return psnr
 
 
-@constexpr
-def _raise_dims_rank_error(input_shape, param_name, func_name):
+@_primexpr
+def _check_rank(rank, input_shape, param_name, func_name):
     """raise error if input is not 3d or 4d"""
-    raise ValueError(f"{func_name} {param_name} must be 3d or 4d, but got shape {input_shape}")
+    def _check():
+        if rank not in (3, 4):
+            raise ValueError(f"{func_name} {param_name} must be 3d or 4d, but got shape {input_shape}")
+    _check()
 
 
-@constexpr
+@_primexpr
 def _get_bbox(rank, shape, central_fraction):
     """get bbox start and size for slice"""
+    n, c, h, w = -1, -1, -1, -1
     if rank == 3:
         c, h, w = shape
     else:
         n, c, h, w = shape
 
-    bbox_h_start = int((float(h) - np.float32(h * central_fraction)) / 2)
-    bbox_w_start = int((float(w) - np.float32(w * central_fraction)) / 2)
+    bbox_h_start = int((float(h) - float(h * central_fraction)) / 2)
+    bbox_w_start = int((float(w) - float(w * central_fraction)) / 2)
     bbox_h_size = h - bbox_h_start * 2
     bbox_w_size = w - bbox_w_start * 2
 
@@ -541,15 +543,14 @@ class CentralCrop(Cell):
     def __init__(self, central_fraction):
         super(CentralCrop, self).__init__()
         validator.check_value_type("central_fraction", central_fraction, [float], self.cls_name)
-        validator.check_float_range(central_fraction, 0.0, 1.0, Rel.INC_RIGHT, 'central_fraction', self.cls_name)
+        validator.check_float_range(central_fraction, 0.0, 1.0, validator.INC_RIGHT, 'central_fraction', self.cls_name)
         self.central_fraction = central_fraction
         self.slice = P.Slice()
 
     def construct(self, image):
         image_shape = F.shape(image)
         rank = len(image_shape)
-        if rank not in (3, 4):
-            return _raise_dims_rank_error(image_shape, "image", self.cls_name)
+        _check_rank(rank, image_shape, "image", self.cls_name)
         if self.central_fraction == 1.0:
             return image
 
@@ -561,63 +562,69 @@ class CentralCrop(Cell):
 
 class PixelShuffle(Cell):
     r"""
-    Applies a pixelshuffle operation over an input signal composed of several input planes. This is useful for
-    implementiong efficient sub-pixel convolution with a stride of :math:`1/r`. For more details, refer to
+    Applies the PixelShuffle operation over input which implements sub-pixel convolutions
+    with stride :math:`1/r` . For more details, refer to
     `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network
     <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.
 
+    Note:
+        The dimension of input Tensor on Ascend should be less than 7.
+
     Args:
-        upscale_factor (int):  factor to increase spatial resolution by, and is a positive integer.
+        upscale_factor (int): factor to shuffle the input, and is a positive integer.
+            `upscale_factor` is the above-mentioned :math:`r`.
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(*, C \times r^2, H, W)` . The dimension of `x` is larger than 2, and
-          the length of third to last dimension can be divisible by `upscale_factor` squared.
+        - **input** (Tensor) - Tensor of shape :math:`(*, C \times r^2, H, W)` . The dimension of `x` is larger than 2,
+          and the length of third to last dimension can be divisible by `upscale_factor` squared.
 
     Outputs:
         - **output** (Tensor) - Tensor of shape :math:`(*, C, H \times r, W \times r)` .
 
     Raises:
         ValueError: If `upscale_factor` is not a positive integer.
-        ValueError: If the length of third to last dimension of `x` is not divisible by `upscale_factor` squared.
-        TypeError: If the dimension of `x` is less than 3.
+        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.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input_x = np.arange(3 * 2 * 9 * 4 * 4).reshape((3, 2, 9, 4, 4))
+        >>> 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(3)
+        >>> pixel_shuffle = nn.PixelShuffle(2)
         >>> output = pixel_shuffle(input_x)
         >>> print(output.shape)
-        (3, 2, 1, 12, 12)
+        (3, 2, 2, 8, 8)
     """
     def __init__(self, upscale_factor):
         super(PixelShuffle, self).__init__()
         self.upscale_factor = upscale_factor
 
-    def construct(self, x):
-        return ops.pixel_shuffle(x, self.upscale_factor)
+    def construct(self, input):
+        return ops.pixel_shuffle(input, self.upscale_factor)
 
 
 class PixelUnshuffle(Cell):
     r"""
-    Applies a pixelunshuffle operation over an input signal composed of several input planes. For more details, refer to
-    `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network
+    Applies the PixelUnshuffle operation over input which is the inverse of PixelShuffle. For more details, refer
+    to `Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional Neural Network
     <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.
 
     Args:
-        downscale_factor (int): factor to decrease spatial resolution by, and is a positive integer.
+        downscale_factor (int): factor to unshuffle the input, and is a positive integer.
+            `downscale_factor` is the above-mentioned :math:`r`.
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(*, C, H \times r, W \times r)` . The dimension of `x` is larger than
-          2, and the length of second to last dimension or last dimension can be divisible by `downscale_factor` .
+        - **input** (Tensor) - Tensor of shape :math:`(*, C, H \times r, W \times r)` . The dimension of `input` is
+          larger than 2, and the length of second to last dimension or last dimension can be divisible by
+          `downscale_factor` .
 
     Outputs:
         - **output** (Tensor) - Tensor of shape :math:`(*, C \times r^2, H, W)` .
@@ -625,22 +632,22 @@ 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 `x` is less than 3.
+        TypeError: If the dimension of `input` is less than 3.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> pixel_unshuffle = nn.PixelUnshuffle(3)
-        >>> input_x = np.arange(12 * 12).reshape((1, 1, 12, 12))
+        >>> pixel_unshuffle = nn.PixelUnshuffle(2)
+        >>> input_x = np.arange(8 * 8).reshape((1, 1, 8, 8))
         >>> input_x = mindspore.Tensor(input_x, mindspore.dtype.int32)
         >>> output = pixel_unshuffle(input_x)
         >>> print(output.shape)
-        (1, 9, 4, 4)
+        (1, 4, 4, 4)
     """
     def __init__(self, downscale_factor):
         super(PixelUnshuffle, self).__init__()
         self.downscale_factor = downscale_factor
 
-    def construct(self, x):
-        return ops.pixel_unshuffle(x, self.downscale_factor)
+    def construct(self, input):
+        return ops.pixel_unshuffle(input, self.downscale_factor)

mindspore/nn/layer/math.py

@@ -17,15 +17,15 @@ from __future__ import absolute_import
 
 import numpy as np
 
+from mindspore import log as logger
 from mindspore.ops import operations as P
 from mindspore.common.tensor import Tensor
 from mindspore.common._decorator import deprecated
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.ops import functional as F
 from mindspore.nn.cell import Cell
 from mindspore.common import dtype as mstype
-from mindspore._checkparam import Validator as validator
-from mindspore.ops._utils.utils import is_shape_unknown
+from mindspore import _checkparam as validator
 
 __all__ = ['ReduceLogSumExp',
            'Range',
@@ -33,6 +33,7 @@ __all__ = ['ReduceLogSumExp',
            'DiGamma',
            'IGamma',
            'LBeta',
+           'CosineSimilarity',
            'MatMul',
            'Moments',
            'MatInverse',
@@ -121,38 +122,15 @@ class ReduceLogSumExp(Cell):
 
 class Range(Cell):
     r"""
-    Creates a sequence of numbers in range [start, limit) with step size delta.
-
-    The size of output is :math:`\left \lfloor \frac{limit-start}{delta}  \right \rfloor + 1` and `delta` is the gap
-    between two values in the tensor.
-
-    .. math::
-
-        out_{i+1} = out_{i} +delta
-
-    Args:
-        start (Union[int, float]): If `limit` is `None`, the value acts as limit in the range and first entry
-            defaults to `0`. Otherwise, it acts as first entry in the range.
-        limit (Union[int, float]): Acts as upper limit of sequence. If `None`, defaults to the value of `start`
-            while set the first entry of the range to `0`. It can not be equal to `start`. Default: None.
-        delta (Union[int, float]): Increment of the range. It can not be equal to zero. Default: 1.
-
-    Outputs:
-        Tensor, the dtype is int if the dtype of `start`, `limit` and `delta` all are int. Otherwise, dtype is float.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> net = nn.Range(1, 8, 2)
-        >>> output = net()
-        >>> print(output)
-        [1 3 5 7]
+    'nn.Range' is deprecated from version 2.0 and will be removed in a future version,
+    use 'ops.range' instead.
     """
 
     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.")
         if delta == 0:
             raise ValueError(f"For '{self.cls_name}', the 'delta' can not be zero.")
         data = np.arange(start, limit, delta)
@@ -256,7 +234,7 @@ class LGamma(Cell):
     def construct(self, x):
         input_dtype = self.dtype(x)
         _check_input_dtype("x", input_dtype, [mstype.float16, mstype.float32], self.cls_name)
-        if is_shape_unknown(self.shape(x)):
+        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)
@@ -590,7 +568,7 @@ class IGamma(Cell):
                    or if x has different dtype with a.
 
     Supported Platforms:
-        ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> a = Tensor(np.array([2.0, 4.0, 6.0, 8.0]).astype(np.float32))
@@ -636,9 +614,8 @@ class IGamma(Cell):
         ax = a * self.log(x) - x - self.lgamma(a)
         para_shape = self.shape(ax)
         if para_shape != ():
-            broadcastto = P.BroadcastTo(para_shape)
-            x = broadcastto(x)
-            a = broadcastto(a)
+            x = F.broadcast_to(x, para_shape)
+            a = F.broadcast_to(a, para_shape)
         x_is_zero = self.equal(x, 0)
         log_maxfloat = self.log_maxfloat32
         underflow = self.less(ax, self.neg(log_maxfloat))
@@ -721,9 +698,8 @@ class LBeta(Cell):
         x_plus_y = x + y
         para_shape = self.shape(x_plus_y)
         if para_shape != ():
-            broadcastto = P.BroadcastTo(para_shape)
-            x = broadcastto(x)
-            y = broadcastto(y)
+            x = F.broadcast_to(x, para_shape)
+            y = F.broadcast_to(y, para_shape)
         comp_less = self.less(x, y)
         x_min = self.select(comp_less, x, y)
         y_max = self.select(comp_less, y, x)
@@ -761,14 +737,17 @@ class LBeta(Cell):
         return self.select(comp_xless8, temp, log_beta_two_large)
 
 
-@constexpr
+@_primexpr
 def get_broadcast_matmul_shape(x_shape, y_shape, prim_name=None):
     """get broadcast_matmul shape"""
     msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
-    if (len(x_shape) < 2) or (len(y_shape) < 2):
-        raise ValueError(f"{msg_prefix} length of 'x_shape' and 'y_shape' must be equal to or greater than 2, "
-                         f"but got the length of 'x_shape': {len(x_shape)} and the length of 'y_shape': "
-                         f"{len(y_shape)}.")
+
+    def _check_len():
+        if (len(x_shape) < 2) or (len(y_shape) < 2):
+            raise ValueError(f"{msg_prefix} length of 'x_shape' and 'y_shape' must be equal to or greater than 2, "
+                             f"but got the length of 'x_shape': {len(x_shape)} and the length of 'y_shape': "
+                             f"{len(y_shape)}.")
+    _check_len()
     x_shape_batch = x_shape[:-2]
     y_shape_batch = y_shape[:-2]
     if x_shape_batch == y_shape_batch:
@@ -777,17 +756,21 @@ def get_broadcast_matmul_shape(x_shape, y_shape, prim_name=None):
     y_len = len(y_shape)
     length = x_len if x_len < y_len else y_len
     broadcast_shape_back = []
+
+    def _check_broadcast(x_val, y_val, i):
+        if not (x_val == 1 or y_val == 1 or x_val == y_val):
+            raise ValueError(f"{msg_prefix} 'x_shape[{i}]' must be equal to 1, or the 'y_shape[{i}]' must be equal "
+                             f"to 1, or the 'x_shape[{i}]' must be equal to 'y_shape[{i}]', but got "
+                             f"'x_shape[{i}]': {x_val}, 'y_shape[{i}]': {y_val}.")
+
     for i in range(-length, -2):
+        _check_broadcast(x_shape[i], y_shape[i], i)
         if x_shape[i] == 1:
             broadcast_shape_back.append(y_shape[i])
         elif y_shape[i] == 1:
             broadcast_shape_back.append(x_shape[i])
-        elif x_shape[i] == y_shape[i]:
-            broadcast_shape_back.append(x_shape[i])
         else:
-            raise ValueError(f"{msg_prefix} 'x_shape[{i}]' must be equal to 1, or the 'y_shape[{i}]' must be equal "
-                             f"to 1, or the 'x_shape[{i}]' must be equal to 'y_shape[{i}]', but got "
-                             f"'x_shape[{i}]': {x_shape[i]}, 'y_shape[{i}]': {y_shape[i]}.")
+            broadcast_shape_back.append(x_shape[i])
 
     broadcast_shape_front = y_shape[0: y_len - length] if length == x_len else x_shape[0: x_len - length]
     x_broadcast_shape = broadcast_shape_front + tuple(broadcast_shape_back) + x_shape[-2:]
@@ -795,10 +778,15 @@ def get_broadcast_matmul_shape(x_shape, y_shape, prim_name=None):
     return x_broadcast_shape, y_broadcast_shape
 
 
-@constexpr
+@_primexpr
 def check_col_row_equal(x1_shape, x2_shape, transpose_x1, transpose_x2, prim_name=None):
     """check col and row equal"""
-    msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
+    def _check(x1_col, x2_row):
+        msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
+        if x1_col != x2_row:
+            raise ValueError(f"{msg_prefix} column of matrix dimensions of 'x1' must be equal to "
+                             f"the row of matrix dimensions of 'x2', but got 'x1_col' {x1_col} and 'x2_row' {x2_row}.")
+
     if len(x1_shape) == 1:
         transpose_x1 = False
         x1_shape = (1,) + x1_shape
@@ -809,9 +797,7 @@ def check_col_row_equal(x1_shape, x2_shape, transpose_x1, transpose_x2, prim_nam
     x2_last = x2_shape[-2:]
     x1_col = x1_last[not transpose_x1]  # x1_col = x1_last[1] if (not transpose_a) else x1_last[0]
     x2_row = x2_last[transpose_x2]  # x2_row = x2_last[0] if (not transpose_b) else x2_last[1]
-    if x1_col != x2_row:
-        raise ValueError(f"{msg_prefix} column of matrix dimensions of 'x1' must be equal to "
-                         f"the row of matrix dimensions of 'x2', but got 'x1_col' {x1_col} and 'x2_row' {x2_row}.")
+    _check(x1_col, x2_row)
 
 
 def matmul_op_select(x1_shape, x2_shape, transpose_x1, transpose_x2):
@@ -872,12 +858,10 @@ class MatMul(Cell):
             x2_shape = self.shape_op(x2)
 
         x1_broadcast_shape, x2_broadcast_shape = get_broadcast_matmul_shape(x1_shape, x2_shape)
-        x1_broadcast_to = P.BroadcastTo(x1_broadcast_shape)
-        x2_broadcast_to = P.BroadcastTo(x2_broadcast_shape)
         if x1_broadcast_shape != x1_shape:
-            x1 = x1_broadcast_to(x1)
+            x1 = F.broadcast_to(x1, x1_broadcast_shape)
         if x2_broadcast_shape != x2_shape:
-            x2 = x2_broadcast_to(x2)
+            x2 = F.broadcast_to(x2, x2_broadcast_shape)
 
         matmul_broadcast = matmul_op(x1, x2)
 
@@ -889,72 +873,80 @@ class MatMul(Cell):
         return matmul_broadcast
 
 
-class Moments(Cell):
-    """
-    Calculate the mean and variance of the input `x` along the specified `axis`.
+class CosineSimilarity(Cell):
+    r"""
+    Computes cosine similarity.
+
+    .. math::
+        \mathcal{K} = \frac{\textbf{x}\textbf{y}^{\top}}{\parallel \textbf{x} \parallel \parallel \textbf{y} \parallel},
+
+    where :math:`\mathcal{K}` is the similarity, :math:`\textbf{x}` is the first tensor `x1`,
+    :math:`\textbf{y}` is the second tensor `x2`.
+
+    To avoid numerical errors when dividing by small numbers,
+    the lower bound of :math:`\parallel \textbf{x} \parallel \parallel \textbf{y} \parallel` is set to `eps`.
 
     Args:
-        axis (Union[int, tuple(int), None]): Calculates the mean and variance along the specified axis.
-            When the value is None, it means to calculate the mean and variance of all values of `x`. Default: None.
-        keep_dims (Union[bool, None]): If True, the calculation result will retain the dimension of `axis`,
-            and the dimensions of the mean and variance are the same as the input. If False or None,
-            the dimension of `axis` will be reduced. Default: None.
+        dim (int, optional): Dimension. Default: 1.
+        eps (float, optional): Small value. Default: 1e-08.
 
     Inputs:
-        - **x** (Tensor) - Tensor of any dimension used to calculate the mean and variance.
-          Only float16 and float32 are supported.
+        - **x1** (Tensor) - The first tensor :math:`\textbf{x}`.
+          Shape: :math:`(\ast_1, D, \ast_2)` where :math:`D` is at position `dim`.
+        - **x2** (Tensor) - The second tensor :math:`\textbf{y}`. The shape is the same as `x1`.
 
     Outputs:
-        - **mean** (Tensor) - The mean value of `x` on `axis`, with the same data type as input `x`.
-        - **variance** (Tensor) - The variance of `x` on `axis`, with the same data type as input `x`.
+        Tensor, with shape :math:`(\ast_1, \ast_2)`, the data type will be inferred automatically.
 
     Raises:
-        TypeError: If `axis` is not one of int, tuple, None.
-        TypeError: If `keep_dims` is neither bool nor None.
-        TypeError: If dtype of `x` is neither float16 nor float32.
+        TypeError: If `x1` or `x2` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> # case1: axis = 0, keep_dims=True
-        >>> x = Tensor(np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]), mindspore.float32)
-        >>> net = nn.Moments(axis=0, keep_dims=True)
-        >>> output = net(x)
-        >>> print(output)
-        (Tensor(shape=[1, 2, 2], dtype=Float32, value=
-        [[[ 3.00000000e+00, 4.00000000e+00],
-          [ 5.00000000e+00, 6.00000000e+00]]]), Tensor(shape=[1, 2, 2], dtype=Float32, value=
-        [[[ 4.00000000e+00, 4.00000000e+00],
-          [ 4.00000000e+00, 4.00000000e+00]]]))
-        >>> # case2: axis = 1, keep_dims=True
-        >>> net = nn.Moments(axis=1, keep_dims=True)
-        >>> output = net(x)
-        >>> print(output)
-        (Tensor(shape=[2, 1, 2], dtype=Float32, value=
-        [[[ 2.00000000e+00, 3.00000000e+00]],
-         [[ 6.00000000e+00, 7.00000000e+00]]]), Tensor(shape=[2, 1, 2], dtype=Float32, value=
-        [[[ 1.00000000e+00, 1.00000000e+00]],
-         [[ 1.00000000e+00, 1.00000000e+00]]]))
-        >>> # case3: axis = 2, keep_dims=None(default)
-        >>> net = nn.Moments(axis=2)
-        >>> output = net(x)
-        >>> print(output)
-        (Tensor(shape=[2, 2], dtype=Float32, value=
-        [[ 1.50000000e+00, 3.50000000e+00],
-         [ 5.50000000e+00, 7.50000000e+00]]), Tensor(shape=[2, 2], dtype=Float32, value=
-        [[ 2.50000000e-01, 2.50000000e-01],
-         [ 2.50000000e-01, 2.50000000e-01]]))
-        >>> # case4: axis = None(default), keep_dims=None(default)
-        >>> net = nn.Moments()
-        >>> output = net(x)
-        >>> print(output)
-        (Tensor(shape=[], dtype=Float32, value= 4.5), Tensor(shape=[], dtype=Float32, value= 5.25))
+        >>> 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()
+        >>> out = func(x1, x2)
+        >>> print(out.asnumpy())
+        [0.9402562 0.8614609 0.9516245]
+    """
+
+    def __init__(self, dim=1, eps=1e-08):
+        """Initialize CosineSimilarity."""
+        super().__init__()
+        self.dim = dim
+        self.eps = eps
+        self.mul = P.Mul()
+        self.div = P.DivNoNan()
+        self.maximum = P.Maximum()
+        self.cast = P.Cast()
+
+    def construct(self, x1, x2):
+        if not isinstance(x1, Tensor):
+            raise TypeError(f"For 'CosineSimilarity', 'x1' must be a tensor, but got {type(x1)}")
+        if not isinstance(x2, Tensor):
+            raise TypeError(f"For 'CosineSimilarity', 'x2' must be a tensor, but got {type(x2)}")
+        w12 = self.mul(x1, x2).sum(self.dim)
+        w1 = self.mul(x1, x1).sum(self.dim)
+        w2 = self.mul(x2, x2).sum(self.dim)
+        n12 = self.maximum(self.mul(w1, w2), self.eps * self.eps).sqrt()
+        out = self.div(w12, n12)
+        return out
+
+
+class Moments(Cell):
+    """
+    'nn.Moments' is deprecated from version 2.0 and will be removed in a future version,
+    use 'ops.var_mean' instead.
     """
 
     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.")
         if axis is None:
             axis = ()
         if isinstance(axis, tuple):