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

mindspore/ops/operations/image_ops.py

@@ -180,7 +180,7 @@ class AdjustHue(Primitive):
 
 
 class ExtractGlimpse(Primitive):
-    """
+    r"""
     Extracts glimpses(usually subarea of rectangle) from the input image Tensor and return as windows.
 
     Note:
@@ -190,34 +190,35 @@ class ExtractGlimpse(Primitive):
     Args:
         centered (bool, optional): An optional `bool`. Indicates if the offset coordinates
             are centered relative to the image, in which case the (0, 0) offset is relative to the center of
-            the center of the input images. If false, the (0, 0) offset corresponds to the upper left corner
-            of the input images. Defaults to `True`.
+            the center of the input images. If ``False`` , the (0, 0) offset corresponds to the upper left corner
+            of the input images. Default: ``True`` .
         normalized (bool, optional): An optional `bool`. indicates if the offset
-            coordinates are normalized. Defaults to `True`.
+            coordinates are normalized. Default: ``True`` .
         uniform_noise (bool, optional): An optional `bool`. indicates if the noise should be
-            generated using a uniform distribution(aka. Gaussian distribution). Defaults to `True`.
+            generated using a uniform distribution(aka. Gaussian distribution). Default: ``True`` .
         noise (str, optional): An optional string specifies the type of noise to fill.
             The window is determined by size and offsets.
             When the window and input image tensor don't not overlap, random noise is filled.
-            The value can be 'uniform', 'gaussian' and 'zero'. Default: `uniform`.
+            The value can be ``'uniform'`` , ``'gaussian'`` and ``'zero'`` . Default: ``uniform`` .
 
-            - When `noise` is 'uniform' and 'gaussian', the result is variable.
-            - When `noise` is 'zero', the value of `uniform_noise` must be 'False' and the
+            - When `noise` is ``'uniform'`` and ``'gaussian'`` , the result is variable.
+            - When `noise` is ``'zero'`` , the value of `uniform_noise` must be ``'False'`` and the
               filling noise will be zero so that the result is fixed.
-            - When `uniform_noise` is 'True', the value of `noise` only can be 'uniform'.
-              When `uniform_noise` is 'False', the value of `noise` can be 'uniform', 'gaussian' and 'zero'.
+            - When `uniform_noise` is ``'True'`` , the value of `noise` only can be ``'uniform'`` .
+              When `uniform_noise` is ``'False'`` , the value of `noise` can be ``'uniform'`` , ``'gaussian'`` or
+              ``'zero'`` .
 
     Inputs:
-        - **x** (Tensor) - A 4-D float tensor of shape :math:`(batch_size, height, width, channels)`.
+        - **x** (Tensor) - A 4-D float tensor of shape :math:`(batch\_size, height, width, channels)`.
           Types allowed: float32.
         - **size** (Tensor) - A 1-D tensor of 2 elements containing the size of the glimpses to extract.
           The glimpse height must be specified first, following by the glimpse width. Types allowed: int32.
           The value of size must be greater than zero.
-        - **offsets** (Tensor) - A 2-D integer tensor of shape :math:`(batch_size, 2)` containing the y, x locations
+        - **offsets** (Tensor) - A 2-D integer tensor of shape :math:`(batch\_size, 2)` containing the y, x locations
           of the center of each window. Types allowed: float32.
 
     Outputs:
-        A 4-D tensor of shape :math:`(batch_size, glimpse_height, glimpse_width, channels)` with type: float32.
+        A 4-D tensor of shape :math:`(batch\_size, glimpse\_height, glimpse\_width, channels)` with type: float32.
 
     Raises:
         TypeError: If `centered` is not a bool.
@@ -276,9 +277,18 @@ class CropAndResize(Primitive):
 
     Args:
         method (str, optional): An optional string that specifies the sampling method for resizing.
-            It can be "bilinear", "nearest" or "bilinear_v2". The option "bilinear" stands for standard bilinear
-            interpolation algorithm, while "bilinear_v2" may result in better result in some cases. Default: "bilinear"
-        extrapolation_value (float, optional): An optional float value used extrapolation, if applicable. Default: 0.0.
+            It can be ``"bilinear"`` , ``"nearest"`` or ``"bilinear_v2"`` . Default: ``"bilinear"`` .
+
+            - ``"nearest"``: Nearest neighbor interpolation. Each output pixel is assigned the value of the
+              nearest input pixel. This method is simple and fast but can result in blocky or pixelated outputs.
+            - ``"bilinear"``: Bilinear interpolation. Each output pixel is a weighted average of the four nearest input
+              pixels, computed using bilinear interpolation. This method produces smoother results compared
+              to nearest neighbor interpolation.
+            - ``"bilinear_v2"``: The optimized variant of
+              ``"bilinear"``, it may achieve better result(higher precision and speed) in some cases.
+
+        extrapolation_value (float, optional): An optional float value used extrapolation, if applicable.
+            Default: ``0.0`` .
 
     Inputs:
         - **x** (Tensor) - The input image must be a 4-D tensor of shape
@@ -320,6 +330,8 @@ class CropAndResize(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import nn, ops, Tensor
         >>> class CropAndResizeNet(nn.Cell):
         ...     def __init__(self, crop_size):
         ...         super(CropAndResizeNet, self).__init__()
@@ -353,7 +365,6 @@ class CropAndResize(Primitive):
         self.method = method
         validator.check_value_type("extrapolation_value", extrapolation_value, [float], self.name)
         self.extrapolation_value = extrapolation_value
-        self.is_ge = context.get_context("enable_ge")
 
 
 class NonMaxSuppressionV3(Primitive):
@@ -465,7 +476,7 @@ class NonMaxSuppressionWithOverlaps(Primitive):
     Raises:
         TypeError: If the dtype of `overlaps` , `scores` `overlap_threshold` and `score_threshold`
                    is not float16, float32 or float64.
-        TypeError: If `overlaps` or `scores` is not Tensor。
+        TypeError: If `overlaps` or `scores` is not Tensor.
         TypeError: If `max_output_size` is not Tensor or Scalar.If `max_output_size` is not int32.
         TypeError: If `overlap_threshold` is not Tensor or scalar. If its type is not float16, float32 or float64.
         TypeError: If `score_threshold` is not Tensor or scalar. If its type is not float16, float32 or float64.
@@ -547,8 +558,8 @@ class CropAndResizeGradBoxes(Primitive):
         Input images and grads must be a 4-D tensor.
 
     Args:
-        method (str): A string specifying the interpolation method. Only "bilinear" is supported for now.
-            Default: "bilinear".
+        method (str): A string specifying the interpolation method. Only ``"bilinear"`` is supported for now.
+            Default: ``"bilinear"`` .
 
     Inputs:
         - **grads** (Tensor) - A 4-D tensor of shape [num_boxes, crop_height, crop_width, depth].
@@ -660,12 +671,12 @@ class ResizeLinear1D(Primitive):
         - Currently, the Ascend platform only supports scenarios where the input `size` is Tuple or List.
 
     Args:
-        coordinate_transformation_mode (str): Default is 'align_corners'. Describes how to transform the coordinate
-            in the resized tensor to the coordinate in the original tensor. Other optional: 'half_pixel'.
+        coordinate_transformation_mode (str): Default is ``'align_corners'`` . Describes how to transform the
+            coordinate in the resized tensor to the coordinate in the original tensor. Other optional: 'half_pixel'.
 
     Inputs:
         - **x** (Tensor) - A 3-D tensor which to resize, with shape [batch, channel, width]. Must be one of the
-          following types: uint8, int8, int16, int32, int64, float16, float32, double.
+          following types: float16, float32, float64.
         - **size** (Union[Tuple[int], List[int], Tensor[int]]): describes the new width of `x` .
           A tuple or list or 1-D tensor with only one int element :math:`(new\_width)`.
 
@@ -711,11 +722,11 @@ class ResizeBilinearV2(Primitive):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        align_corners (bool, optional): If true, rescale input by :math:`(new\_height - 1) / (height - 1)`,
-                       which exactly aligns the 4 corners of images and resized images. If false,
-                       rescale by :math:`new\_height / height`. Default: False.
-        half_pixel_centers (bool, optional): Whether half pixel center. If set to True, `align_corners` should be False.
-                           Default: False.
+        align_corners (bool, optional): If ``True`` , rescale input by :math:`(new\_height - 1) / (height - 1)`,
+                       which exactly aligns the 4 corners of images and resized images. If ``False`` ,
+                       rescale by :math:`new\_height / height`. Default: ``False`` .
+        half_pixel_centers (bool, optional): Whether half pixel center. If set to ``True`` , `align_corners` should be
+                           ``False`` . Default: ``False`` .
 
     Inputs:
         - **x** (Tensor): Image to be resized. Input images must be a 4-D tensor with shape
@@ -730,8 +741,8 @@ class ResizeBilinearV2(Primitive):
     Raises:
         TypeError: If `align_corners` is not a bool.
         TypeError: If `half_pixel_centers` is not a bool.
-        TypeError: If `align_corners` and `half_pixel_centers` are all True.
-        ValueError: If `half_pixel_centers` is True and device_target is CPU.
+        TypeError: If `align_corners` and `half_pixel_centers` are all ``True`` .
+        ValueError: If `half_pixel_centers` is ``True`` and device_target is CPU.
         ValueError: If dim of `x` is not 4.
         ValueError: If `size` is Tensor and its dim is not 1.
         ValueError: If `size` contains other than 2 elements.
@@ -740,6 +751,8 @@ class ResizeBilinearV2(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([[[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]]], mindspore.float32)
         >>> output = ops.ResizeBilinearV2()(x, (5, 5))
         >>> print(output)
@@ -766,38 +779,44 @@ class ResizeBicubic(Primitive):
     r"""
     Resize images to size using bicubic interpolation.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
-        align_corners (bool, optional):If true, the centers of the 4 corner pixels of the input
-            and output tensors are aligned, preserving the values at the corner pixels.Default: False.
-        half_pixel_centers (bool, optional): Whether to use half-pixel center alignment. If set to True,
-            `align_corners` should be False. Default: False.
+        align_corners (bool, optional): If ``True`` , the centers of the 4 corner pixels of the input
+            and output tensors are aligned, preserving the values at the corner pixels. Default: ``False`` .
+        half_pixel_centers (bool, optional): Whether to use half-pixel center alignment. If set to ``True`` ,
+            `align_corners` should be ``False`` . Default: ``False`` .
 
     Inputs:
         - **images** (Tensor) - The input image must be a 4-D tensor of shape :math:`(batch, channels, height, width)`.
           The format must be NCHW.
-          Types allowed: int8, int16, int32, int64, float16, float32, float64, uint8, uint16.
-        - **size** (Tensor) - A 1-D tensor of shape [2], with 2 elements: new_height, new_width.
+          Types allowed: float16, float32, float64.
+        - **size** (Tensor) - A 1-D tensor with 2 elements: new_height, new_width.
           Types allowed: int32.
 
     Outputs:
-        A 4-D tensor of shape :math:`(batch, channels, new\_height, new\_width)` with type float32.
+        A 4-D tensor with shape :math:`(batch, channels, new\_height, new\_width)` whose dtype is the same as `images` .
 
     Raises:
-        TypeError: If `images` type is not allowed.
-        TypeError: If `size` type is not int32.
-        TypeError: If `align_corners` type is not bool.
-        TypeError: If `half_pixel_centers` type is not bool.
-        ValueError: If `images` dim is not 4.
-        ValueError: If `size` dim is not 1.
-        ValueError: If `size` size is not 2.
-        ValueError: If any `size` value is not positive.
-        ValueError: If `align_corners` and `half_pixel_centers` value are both True.
+        TypeError: If the type of `images` is not allowed.
+        TypeError: If the type of `size` is not int32.
+        TypeError: If the type of `align_corners` is not bool.
+        TypeError: If the type of `half_pixel_centers` is not bool.
+        ValueError: If the dim of `images` is not 4.
+        ValueError: If the dim of `size` is not 1.
+        ValueError: If the number of elements in `size` is not 2.
+        ValueError: If any value of `size` is not positive.
+        ValueError: If the values of `align_corners` and `half_pixel_centers` are both ``True`` .
 
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> class NetResizeBicubic(nn.Cell):
         ...     def __init__(self):
         ...         super(NetResizeBicubic, self).__init__()
@@ -808,15 +827,12 @@ class ResizeBicubic(Primitive):
         ...     def construct(self, images, size):
         ...         return self.resize(images, size)
         ...
-        >>> images = Tensor(np.array([1, 2, 3, 4]).reshape(1, 2, 2, 1).astype(np.float32))
+        >>> images = Tensor(np.array([1, 2, 3, 4]).reshape(1, 1, 2, 2).astype(np.float32))
         >>> size = Tensor([1, 4], mindspore.int32)
         >>> resizebicubic = NetResizeBicubic()
         >>> output = resizebicubic(images, size)
         >>> print(output)
-            [[[[1.     ]
-            [1.5    ]
-            [2.     ]
-            [2.09375]]]]
+            [[[[1. 1.5 2. 2.09375]]]]
     """
 
     @prim_attr_register
@@ -873,14 +889,13 @@ class ResizeArea(Primitive):
     Args:
         align_corners (bool, optional): A boolean flag that specifies whether
             to align the centers of the four corner pixels of the input and output tensors.
-            When this flag is set to True, the corner pixels of the output tensor are aligned
+            When this flag is set to ``True`` , the corner pixels of the output tensor are aligned
             with the corner pixels of the input tensor, which preserves the values at the corner pixels.
-            Defaults: False.
+            Default: ``False`` .
 
     Inputs:
         - **images** (Tensor) -  Input images must be a 4-D tensor with shape
           which is :math:`(batch, channels, height, width)`. The format must be "NHWC".
-          Types allowed: int8, int16, int32, int64, float16, float32, float64, uint8, uint16.
         - **size** (Tensor) - Input size must be a 1-D tensor of 2 elements: new_height, new_width.
           The new size of output image.
           Types allowed: int32.
@@ -927,8 +942,8 @@ class CropAndResizeGradImage(Primitive):
         Input grads must be a 4-D tensor.
 
     Args:
-        method (str): A string specifying the interpolation method. "bilinear", "nearest" and "bilinear_v2" are
-            supported for now. "bilinear_v2" only supports GPU. Default: "bilinear".
+        method (str): A string specifying the interpolation method. ``"bilinear"`` , ``"nearest"`` and
+            ``"bilinear_v2"`` are supported for now. ``"bilinear_v2"`` only supports GPU. Default: ``"bilinear"`` .
         T (mindspore.dtype): T is a required attribute. The value range of T is {mindspore.float16, mindspore.float32,
             mindspore.float64}.
 
@@ -1029,9 +1044,9 @@ class ScaleAndTranslate(Primitive):
 
     Args:
         kernel_type (str, optional): Deciding which image filtering algorithm to choose. Valid options:
-            ["lanczos1", "lanczos3", "lanczos5", "gaussian", "box", "triangle", "keyscubic", "mitchellcubic"]
-            Default: "lanczos3".
-        antialias (bool, optional): Deciding whether to use the antialias. Default: True.
+            [ ``"lanczos1"`` , ``"lanczos3"`` , ``"lanczos5"`` , ``"gaussian"`` , ``"box"`` , ``"triangle"`` ,
+            ``"keyscubic"`` , ``"mitchellcubic"`` ]. Default: ``"lanczos3"`` .
+        antialias (bool, optional): Deciding whether to use the antialias. Default: ``True`` .
 
     Inputs:
         - **images** (Tensor) - A 4-D tensor of shape :math:`(batch, image\_height, image\_width, channel)`.
@@ -1093,26 +1108,26 @@ class CombinedNonMaxSuppression(Primitive):
 
     Args:
         clip_boxes (bool, optional): Determines whether to apply bounding box normalization to ensure the
-            coordinates are within [0, 1] range. Default: True.
+            coordinates are within [0, 1] range. Default: ``True`` .
 
-            - If True, clip the boxes that fall outside this range.
-            - If False, return the box coordinates as they are without any modifications.
+            - If ``True`` , clip the boxes that fall outside this range.
+            - If ``False`` , return the box coordinates as they are without any modifications.
 
         pad_per_class (bool, optional): Determines whether the output of the non-maximum suppression (NMS)
-            algorithm should be padded or clipped to meet the maximum size constraints. Default: False.
+            algorithm should be padded or clipped to meet the maximum size constraints. Default: ``False`` .
 
-            - If False, the output is clipped to the maximum size of `max_total_size`.
-            - If True, the output is padded up to `max_size_per_class` * `num_classes` and clipped if
+            - If ``False`` , the output is clipped to the maximum size of `max_total_size`.
+            - If ``True`` , the output is padded up to `max_size_per_class` * `num_classes` and clipped if
               it exceeds `max_total_size`.
 
     Inputs:
-        - **boxes** (Tensor) - A float32 Tensor with shape :math:`(batch_size, num_boxes, q, 4)`
+        - **boxes** (Tensor) - A float32 Tensor with shape :math:`(batch\_size, num\_boxes, q, 4)`
           representing the bounding box coordinates.
           `q` indicates mapping relationship between boxes and classes.
           If `q` is 1, all classes use the same bounding box. If `q` is equal to the number of classes,
           class-specific boxes are applied.
         - **scores** (Tensor) - A 3-D Tensor of float32 type with the shape
-          :math:`(batch_size, num_boxes, num_classes)`. It contains a score value for each box,
+          :math:`(batch\_size, num\_boxes, num\_classes)`. It contains a score value for each box,
           with each row of `boxes` represented by a single score.
         - **max_output_size_per_class** (Tensor) - The maximum number of boxes that can be selected for each class
           by the non-maximum suppression algorithm, represented by a scalar Tensor of type int32.
@@ -1187,10 +1202,10 @@ class ResizeV2(Primitive):
         Input x must be a 4-D tensor.
 
     Args:
-        coordinate_transformation_mode (str): Default is 'half_pixel'. Describes how to transform the
-            coordinate in the resized tensor to the coordinate in the original tensor. Other optional: 'align_corners'.
-            In 'nearest' mode, coordinate_transformation_mode must be 'half_pixel'.
-        mode (str): Defaults to 'nearest'. Other optional: 'linear' and 'cubic'.
+        coordinate_transformation_mode (str): Default is ``'half_pixel'`` . Describes how to transform the
+            coordinate in the resized tensor to the coordinate in the original tensor. Other optional:
+            ``'align_corners'`` . In ``'nearest'`` mode, coordinate_transformation_mode must be ``'half_pixel'`` .
+        mode (str): Default: ``'nearest'`` . Other optional: ``'linear'`` and ``'cubic'`` .
 
     Inputs:
         - **x** (Tensor) - A 4-D tensor which to resize, with shape [batch, channel, width, height]. Must be one of the

mindspore/ops/operations/inner_ops.py

@@ -19,7 +19,6 @@ import numbers
 import numpy as np
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
-from mindspore.common.dtype import tensor
 from mindspore.ops.primitive import prim_attr_register, PrimitiveWithInfer, Primitive
 from mindspore.ops import signature as sig
 
@@ -34,6 +33,8 @@ class ScalarCast(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
         >>> scalar_cast = ops.ScalarCast()
         >>> output = scalar_cast(255.0, mindspore.int32)
         >>> print(output)
@@ -46,7 +47,7 @@ class ScalarCast(Primitive):
 
     def __call__(self, x, dtype):
         validator.check_value_type("x", x, [bool, numbers.Number], self.name)
-        if isinstance(dtype, type(tensor)):
+        if isinstance(dtype, type(mstype.tensor_type)):
             dtype = dtype.element_type()
         np_dtype = str(dtype)
         value = np.cast[np_dtype.lower()](x)
@@ -60,9 +61,9 @@ class Randperm(Primitive):
     the last `max_length-n` elements will be filled with `pad`.
 
     Args:
-        max_length (int): Number of items expected to get and the number must be greater than 0. Default: 1.
-        pad (int): The pad value to be filled. Default: -1.
-        dtype (mindspore.dtype): The type of output. Default: mindspore.int32.
+        max_length (int): Number of items expected to get and the number must be greater than 0. Default: ``1`` .
+        pad (int): The pad value to be filled. Default: ``-1`` .
+        dtype (mindspore.dtype): The type of output. Default: ``mstype.int32`` .
 
     Inputs:
         - **n** (Tensor) - The input tensor with shape :math:`(1,)` with and dtype int32 or int64.
@@ -84,6 +85,8 @@ class Randperm(Primitive):
         ``Ascend`` ``GPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> # The result of every execution is different because this operator will generate n random samples.
         >>> randperm = ops.Randperm(max_length=30, pad=-1)
         >>> n = Tensor([20], dtype=mindspore.int32)
@@ -118,7 +121,7 @@ class NoRepeatNGram(Primitive):
     Because 3 consecutive words [2, 3, 2] do not appear twice in the word sequence.
 
     Args:
-        ngram_size (int): Size of n-grams, must be greater than 0. Default: 1.
+        ngram_size (int): Size of n-grams, must be greater than 0. Default: ``1`` .
 
     Inputs:
         - **state_seq** (Tensor) - n-gram word series, a 3-D tensor with shape: :math:`(batch\_size, beam\_width, m)`.
@@ -144,6 +147,8 @@ class NoRepeatNGram(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> no_repeat_ngram = ops.NoRepeatNGram(ngram_size=3)
         >>> state_seq = Tensor([[[1, 2, 1, 2, 5, 1, 2],
         ...                      [9, 3, 9, 5, 4, 1, 5]],
@@ -328,9 +333,9 @@ class FusedWeightScaleApplyMomentum(PrimitiveWithInfer):
 
     Inputs:
         - **weight_decay** (Tensor) - The weight decay value, must be a scalar tensor with float data type.
-          Default: 0.0.
+          Default: ``0.0`` .
         - **loss_scale** (Tensor) - The loss scale value, must be a scalar tensor with float data type.
-          Default: 1.0.
+          Default: ``1.0`` .
         - **variable** (Parameter) - Weights to be updated. data type must be float.
         - **accumulation** (Parameter) - Accumulated gradient value by moment weight.
           Has the same data type with `variable`.
@@ -413,8 +418,8 @@ class FusedCastAdamWeightDecay(PrimitiveWithInfer):
 
     Args:
         use_locking (bool): Whether to enable a lock to protect variable tensors from being updated.
-            If true, updates of the var, m, and v tensors will be protected by a lock.
-            If false, the result is unpredictable. Default: False.
+            If ``True`` , updates of the var, m, and v tensors will be protected by a lock.
+            If ``False`` , the result is unpredictable. Default: ``False`` .
 
     Inputs:
         - **var** (Tensor) - Weights to be updated with the type float16 or float32.
@@ -543,9 +548,9 @@ class FusedAdaFactor(PrimitiveWithInfer):
     :math:`C` is the running averages of the column sums of the squared gradient.
 
     Args:
-        enable_weight_decay (bool): If True, enable weight decay. default: False
-        enable_first_moment (bool): If True, enable first moment. default: False
-        enable_scale_parameter (bool): If True, enable scale learning rate using parameter. default: False
+        enable_weight_decay (bool): If ``True`` , enable weight decay. Default: ``False`` .
+        enable_first_moment (bool): If ``True`` , enable first moment. Default: ``False`` .
+        enable_scale_parameter (bool): If ``True`` , enable scale learning rate using parameter. Default: ``False`` .
 
     Inputs:
         - **epsilon** (Tensor) - input epsilon pair.

mindspore/ops/operations/linalg_ops.py

@@ -45,13 +45,15 @@ class Geqrf(Primitive):
 
     Raises:
         TypeError: If `x` is not a Tensor.
-        TypeError: If the dtype of `x` is neither float32, float64, complex64, complex128.
-        ValueError: If `x` dimension is less than 2
+        TypeError: If the dtype of `x` is not float32, float64, complex64 or complex128.
+        ValueError: If dimension of `x` is less than 2.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[-2.0, -1.0], [1.0, 2.0]]).astype(np.float32))
         >>> geqrf = ops.Geqrf()
         >>> y, tau = geqrf(input_x)
@@ -75,11 +77,11 @@ class Svd(Primitive):
     Refer to :func:`mindspore.ops.svd` for more details.
 
     Args:
-        full_matrices (bool, optional): If true, compute full-sized :math:`U` and :math:`V`. If false, compute
-                                        only the leading P singular vectors, with P is the minimum of M and N.
-                                        Default: False.
-        compute_uv (bool, optional): If true, compute the left and right singular vectors.
-                                     If false, compute only the singular values. Default: True.
+        full_matrices (bool, optional): If ``True`` , compute full-sized :math:`U` and :math:`V`. If ``False``,
+                                        compute only the leading P singular vectors, with P is the minimum of M and N.
+                                        Default: ``False`` .
+        compute_uv (bool, optional): If ``True`` , compute the left and right singular vectors.
+                                     If ``False`` , compute only the singular values. Default: ``True`` .
 
     Inputs:
         - **input** (Tensor) - Tensor of the matrices to be decomposed. The shape should be :math:`(*, M, N)`,
@@ -87,10 +89,10 @@ class Svd(Primitive):
 
     Outputs:
         - **s**  (Tensor) - Singular values. The shape is :math:`(*, P)`.
-        - **u**  (Tensor) - Left singular vectors. If `compute_uv` is False, u will be zero value.
-          The shape is :math:`(*, M, P)`. If `full_matrices` is True, the shape will be :math:`(*, M, M)`.
-        - **v**  (Tensor) - Right singular vectors. If `compute_uv` is False, v will be zero value.
-          The shape is :math:`(*, N, P)`. If `full_matrices` is True, the shape will be :math:`(*, N, N)`.
+        - **u**  (Tensor) - Left singular vectors. If `compute_uv` is ``False`` , u will be zero value.
+          The shape is :math:`(*, M, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, M, M)`.
+        - **v**  (Tensor) - Right singular vectors. If `compute_uv` is ``False`` , v will be zero value.
+          The shape is :math:`(*, N, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, N, N)`.
 
     Supported Platforms:
         ``GPU`` ``CPU``
@@ -122,3 +124,20 @@ class Svd(Primitive):
         self.compute_uv = Validator.check_value_type("compute_uv", compute_uv, [bool], self.name)
         self.add_prim_attr('full_matrices', self.full_matrices)
         self.add_prim_attr('compute_uv', self.compute_uv)
+
+
+class Eigh(Primitive):
+    """
+    Eigh decomposition(Symmetric matrix)
+    Ax = lambda * x
+    """
+
+    @prim_attr_register
+    def __init__(self, compute_eigenvectors=True, lower=True):
+        super().__init__(name="Eigh")
+        self.init_prim_io_names(inputs=['A'], outputs=['output_w', 'output_v'])
+        self.compute_eigenvectors = Validator.check_value_type(
+            "compute_eigenvectors", compute_eigenvectors, [bool], self.name)
+        self.lower = Validator.check_value_type("lower", lower, [bool], self.lower)
+        self.add_prim_attr('lower', self.lower)
+        self.add_prim_attr('compute_eigenvectors', self.compute_eigenvectors)