mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops/operations/image_ops.py

@@ -14,9 +14,10 @@
 # ============================================================================
 
 """image_ops"""
+
+from __future__ import absolute_import
 from mindspore import context
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+from mindspore import _checkparam as validator
 from mindspore.ops.primitive import prim_attr_register, Primitive
 from mindspore.common import dtype as mstype
 
@@ -30,19 +31,23 @@ class AdjustSaturation(Primitive):
         adds an offset to the saturation channel, converts back to RGB and then back to the original data type.
         If several adjustments are chained it is advisable to minimize the number of redundant conversions.
 
-    inputs:
-        - **image** (Tensor): Images to adjust. Must be one of the following types: float16, float32.
-           At least 3-D.The last dimension is interpreted as channels, and must be three.
-        - **scale** (Tensor): A float scale to add to the saturation. A Tensor of type float32. Must be 0-D.
+    Inputs:
+        - **image** (Tensor) - Images to adjust. Must be one of the following types: float16, float32.
+          At least 3-D. The last dimension is interpreted as channels, and must be three.
+        - **scale** (Tensor) - A scale factor determines the amount of saturation adjustment to
+          apply to the image. A value greater than 1.0 increases the saturation, while a value less than
+          1.0 decreases the saturation. A value of 1.0 leaves the saturation unchanged.
+          Must be 0-D Tensor of type float32.
 
-    Output:
+    Outputs:
         Adjusted image(s), same shape and dtype as `image`.
 
     Raises:
         TypeError: If any iput is not Tensor.
         TypeError: If the type of `image` is not one of the following dtype: float16, float32.
         TypeError: If the type of `scale` is not float32.
-        ValueError: If the dimension of the 'image' is less than 3, or the last dimension of the 'image' is not 3.
+        ValueError: If the dimension of the 'image' is less than 3.
+        ValueError: If the last dimension of the 'image' is not 3.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -78,12 +83,12 @@ class AdjustContrastv2(Primitive):
         The other dimensions only represent a collection of images, such as [batch, height, width, channels].
         Contrast is adjusted independently for each channel of each image.
 
-    inputs:
+    Inputs:
         -**images**(tensor): Images to adjust. Must be one of the following types: float16, float32.
           At least 3-D.The last dimension is interpreted as channels, and must be three.
         -**contrast_factor**(tensor): A float multiplier for adjusting contrast. A Tensor of type float32. Must be 0-D.
 
-    Output:
+    Outputs:
         Adjusted image(s), same shape and dtype as `images`.
 
     Raises:
@@ -93,7 +98,7 @@ class AdjustContrastv2(Primitive):
         ValueError: If the dimension of the 'images' is less than 3, or the last dimension of the 'images' is not 3.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
     >>> images = Tensor([[[1.0, 2.0, 3.0],
@@ -128,18 +133,19 @@ class AdjustHue(Primitive):
         It is recommended to minimize the number of redundant transformations when several adjustments are chained.
 
     Inputs:
-        - **image** (Tensor): RGB image or images. The size of the last dimension must be 3.
-          the dtype is float16 or float32.  At least 3-D.
+        - **image** (Tensor): RGB image or images, a Tensor has at least 3-D.
+          The last dimension is interpreted as channels whose size must be three.
+          the dtype is float16 or float32.
         - **delta** (Tensor): How much to add to the hue channel, the dtype is float32. Must be 0-D.
 
-    Output:
+    Outputs:
         Adjusted image(s), same shape and dtype as `image`.
 
     Raises:
         TypeError: If neither `image` nor `delta` is a tensor.
-        TypeError: If the dtype of image not float16 or float32.
-        TypeError: If the dtype of delta not float32.
-        ValueError: If image have at less than 3 dimensions.
+        TypeError: If the dtype of `image` is neither float16 nor float32.
+        TypeError: If the dtype of `delta` not float32.
+        ValueError: If the dimension of `image` is less than 3.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -175,40 +181,43 @@ class AdjustHue(Primitive):
 
 class ExtractGlimpse(Primitive):
     """
-    Extracts glimpse from the input image tensor and return a window.
+    Extracts glimpses(usually subarea of rectangle) from the input image Tensor and return as windows.
 
     Note:
-        If the window and input image tensor not overlap, random noise is filled.
+        If extracted windows and the input image only partially overlap,
+        random noise is filled in those non overlapping areas.
 
     Args:
-        centered (bool): An optional `bool`. Defaults to `True`. Indicates if the offset coordinates
+        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.
-        normalized (bool): An optional `bool`. Defaults to `True`. indicates if the offset
-            coordinates are normalized.
-        uniform_noise (bool): An optional `bool`. Defaults to `True`. indicates if the noise should be
-            generated using a uniform distribution or a Gaussian distribution.
-        noise (str): An optional string that defaults to `uniform`. The value can be 'uniform', 'gaussian'
-            and 'zero'. The window is determined by size and offsets.
-            When the window and input image tensor not overlap, random noise is filled.
-            The result is variable when noise is equal to 'uniform' and 'gaussian'.
-            When noise is equal to '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'.
+            of the input images. Defaults to `True`.
+        normalized (bool, optional): An optional `bool`. indicates if the offset
+            coordinates are normalized. Defaults to `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`.
+        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`.
+
+            - 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'.
 
     Inputs:
-        - **x** (Tensor) - A 4-D float tensor of shape [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 [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 [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.
@@ -221,32 +230,23 @@ class ExtractGlimpse(Primitive):
         ValueError: If the input is not Tensor.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> class ExtractGlimpse(nn.Cell):
-        ...         def __init__(self, size, centered, normalized, uniform_noise, noise):
-        ...             super(ExtractGlimpse, self).__init__()
-        ...             self.size = size
-        ...             self.attribute = P.ExtractGlimpse(centered = centered, normalized = normalized,
-        ...             uniform_noise = uniform_noise, noise = noise)
-        ...         def construct(self, x, offsets):
-        ...             return self.attribute(x, self.size, offsets);
-        >>> x = Tensor(np.random.randn(1, 4, 2, 3).astype(np.float32))
-        >>> size = Tensor(np.array([2, 2]).astype("int32"))
-        >>> offsets = Tensor(np.array([[0, 0]]).astype("float32"))
-        >>> attribute = ExtractGlimpse(size, True, True, True, "uniform")
-        >>> output = attribute(x, offsets)
+        >>> x = Tensor([[[[0.0], [1.0], [2.0]], [[3.0], [4.0], [5.0]], [[6.0], [7.0], [8.0]]]], dtype=mindspore.float32)
+        >>> size = Tensor((2, 2), dtype=mindspore.int32)
+        >>> offsets = Tensor([[1, 1]], dtype=mindspore.float32)
+        >>> ops = P.image_ops.ExtractGlimpse(centered = False, normalized = False,
+        >>>                                  uniform_noise = False, noise = "uniform")
+        >>> output = ops(x, size, offsets)
         >>> print(output)
-        [[[[ 0.95008844 -0.1513572  -0.10321885]
-           [ 0.41059852  0.14404356  1.4542735 ]]
-
-          [[ 0.7610377   0.12167501  0.44386324]
-           [ 0.33367434  1.4940791  -0.20515826]]]]
+        [[[[0.]
+           [1.]]
+          [[3.]
+           [4.]]]]
     """
     @prim_attr_register
     def __init__(self, centered=True, normalized=True, uniform_noise=True, noise="uniform"):
-        self.add_prim_attr("max_length", 1000000)
         self.init_prim_io_names(inputs=['x', 'size', 'offsets'], outputs=['output'])
         self.centered = centered
         self.normalized = normalized
@@ -267,7 +267,7 @@ class ExtractGlimpse(Primitive):
 
 
 class CropAndResize(Primitive):
-    """
+    r"""
     Extracts crops from the input image tensor and resizes them.
 
     Note:
@@ -281,27 +281,39 @@ class CropAndResize(Primitive):
         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 [batch, image_height, image_width, depth].
+        - **x** (Tensor) - The input image must be a 4-D tensor of shape
+          :math:`(batch, image\_height, image\_width, depth)`.
           Types allowed: int8, int16, int32, int64, float16, float32, float64, uint8, uint16.
-        - **boxes** (Tensor) - A 2-D tensor of shape [num_boxes, 4].
+        - **boxes** (Tensor) - A 2-D tensor of shape :math:`(num\_boxes, 4)`.
           The i-th row of the tensor specifies the coordinates of a box in the box_ind[i] image
           and is specified in normalized coordinates [y1, x1, y2, x2]. A normalized coordinate value of y is mapped to
           the image coordinate at y * (image_height - 1), so as the [0, 1] interval of normalized image height is
           mapped to [0, image_height - 1] in image height coordinates. We do allow y1 > y2, in which case the sampled
           crop is an up-down flipped version of the original image. The width dimension is treated similarly.
-          Normalized coordinates outside the [0, 1] range are allowed, in which case we use extrapolation_value to
+          Normalized coordinates outside the [0, 1] range are allowed, in which case we use `extrapolation_value` to
           extrapolate the input image values. Types allowed: float32.
-        - **box_index** (Tensor) - A 1-D tensor of shape [num_boxes] with int32 values in [0, batch).
-          The value of box_ind[i] specifies the image that the i-th box refers to. Types allowed: int32.
+        - **box_index** (Tensor) - A 1-D tensor of shape :math:`(num\_boxes)` with int32 values in [0, batch).
+          The value of `box_index[i]` specifies the image that the i-th box refers to. Types allowed: int32.
         - **crop_size** (Tuple[int]) - A tuple of two int32 elements: (crop_height, crop_width).
           Only constant value is allowed. All cropped image patches are resized to this size.
           The aspect ratio of the image content is not preserved. Both crop_height and crop_width need to be positive.
+
     Outputs:
-        A 4-D tensor of shape [num_boxes, crop_height, crop_width, depth] with type: float32.
+        A 4-D tensor of shape :math:`(num\_boxes, crop\_height, crop\_width, depth)` with type: float32.
 
     Raises:
+        TypeError: If `x` or `boxes` or `box_index` is not a Tensor.
+        TypeError: If `crop_size` is not a Tuple with two int32 elements.
+        TypeError: If dtype of `boxes` is not float or that of `box_index` is not int.
         TypeError: If `method` is not a str.
         TypeError: If `extrapolation_value` is not a float.
+        ValueError: If the shape rank of `x` is not 4.
+        ValueError: If the shape rank of `boxes` is not 2.
+        ValueError: If the second dim of `boxes` is not 4.
+        ValueError: If the shape rank of `box_index` is not 1.
+        ValueError: If the first dim of `box_index` is not equal to that of `boxes`.
+        ValueError: If existing element in `box_index` is out of range `[0, batch)`.
+        ValueError: If the data of `crop_size` is not positive.
         ValueError: If `method` is not one of 'bilinear', 'nearest', 'bilinear_v2'.
 
     Supported Platforms:
@@ -346,48 +358,52 @@ class CropAndResize(Primitive):
 
 class NonMaxSuppressionV3(Primitive):
     r"""
-        Greedily selects a subset of bounding boxes in descending order of score.
+    Selects a subset of bounding boxes in a greedy manner, based on their descending score.
+    It removes boxes that have high intersection-over-union (IOU) overlap with previously
+    selected boxes, and eliminates boxes with scores lower than a given threshold.
 
     .. warning::
-        When input "max_output_size" is negative, it will be treated as 0.
+        When input `max_output_size` is negative, it will be treated as 0.
 
     Note:
-        This algorithm is agnostic to where the origin is in the coordinate system.
-        This algorithm is invariant to orthogonal transformations and translations of the coordinate system;
-        thus translating or reflections of the coordinate system result in the same boxes being
-        selected by the algorithm.
+        - This algorithm does not depend on the location of the origin in the coordinate system.
+        - This algorithm remains unaffected by orthogonal transformations and translations of
+          the coordinate system, which means that translating or reflecting the coordinate system
+          will result in the same boxes being chosen by the algorithm.
 
     Inputs:
-        - **boxes** (Tensor) - A 2-D Tensor of shape [num_boxes, 4].
-        - **scores** (Tensor) - A 1-D Tensor of shape [num_boxes] representing a single score
-          corresponding to each box (each row of boxes), the num_boxes of "scores" must be equal to
-          the num_boxes of "boxes".
+        - **boxes** (Tensor) - A 2-D Tensor of shape :math:`(num\_boxes, 4)`.
+        - **scores** (Tensor) - A 1-D Tensor of shape :math:`(num\_boxes)` where each element represents a
+          single score associated with each box (i.e., each row of the `boxes` Tensor).
+          It is required that the number of scores in `scores` must be equal to the number of boxes in `boxes`.
+          The supported data type is float32.
         - **max_output_size** (Union[Tensor, Number.Int]) - A scalar integer Tensor representing the maximum
-          number of boxes to be selected by non max suppression.
-        - **iou_threshold** (Union[Tensor, Number.Float]) - A 0-D float tensor representing the threshold for
-          deciding whether boxes overlap too much with respect to IOU, and iou_threshold must be equal or greater
-          than 0 and be equal or smaller than 1.
-        - **score_threshold** (Union[Tensor, Number.Float]) - A 0-D float tensor representing the threshold for
-          deciding when to remove boxes based on score.
+          number of boxes to be selected by non max suppression. The supported data type is int32.
+        - **iou_threshold** (Union[Tensor, Number.Float]) - A scalar float Tensor represents the threshold
+          used for determining if the intersection over union (IOU) between boxes is too high.
+          Data type of `iou_threshold` is float32 and must be in range [0, 1].
+        - **score_threshold** (Union[Tensor, Number.Float]) - A scalar float Tensor represents the threshold for
+          determining when to remove boxes based on score. The supported data type is float32.
 
     Outputs:
-        A 1-D integer Tensor of shape [M] representing the selected indices from the boxes tensor,
-        where M <= max_output_size.
+        A 1-D integer Tensor of shape :math:`(M)` representing the selected indices from the boxes tensor,
+        where M <= `max_output_size`.
 
     Raises:
-        TypeError: If the dtype of `boxes` and `scores` is different.
-        TypeError: If the dtype of `iou_threshold` and `score_threshold` is different.
+        TypeError: If the dtype of `boxes` and `scores` are different.
+        TypeError: If the dtype of `iou_threshold` and `score_threshold` are different.
         TypeError: If `boxes` is not tensor or its dtype is not float16 or float32.
-        TypeEroor: If `scores` is not tensor or its dtype is not float16 or float32.
-        TypeError: If `max_output_size` is not tensor or scalar.If `max_output_size` is not int32 or int64.
-        TypeError: If `iou_threshold` is not tensor or scalar. If its type is not float16 or float32.
-        TypeError: If `score_threshold` is not tensor or scalar. If its type is not float16 or float32.
+        TypeError: If `scores` is not tensor or its dtype is not float16 or float32.
+        TypeError: If `max_output_size` is not tensor or scalar or its date type is not int32 or int64.
+        TypeError: If `iou_threshold` is not tensor or scalar or its type is neither float16 or float32.
+        TypeError: If `score_threshold` is not tensor or scalar or its type is neither float16 or float32.
         ValueError: If the size of shape of `boxes` is not 2 or the second value of its shape is not 4.
         ValueError: If the size of shape of `scores` is not 1.
-        ValueError: If each of the size of shape of `max_output_size`, `iou_threshold`, `score_threshold` is not 0.
+        ValueError: If any of the size of shape of `max_output_size`,
+            `iou_threshold`, `score_threshold` is not 0.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU``
 
     Examples:
         >>> boxes = Tensor(np.array([[1, 2, 3, 4], [1, 3, 3, 4], [1, 3, 4, 4],
@@ -405,64 +421,70 @@ class NonMaxSuppressionV3(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize NonMaxSuppressionV3"""
+        self.init_prim_io_names(inputs=['boxes', 'scores', 'max_output_size', 'iou_threshold', 'score_threshold'],
+                                outputs=['selected indices'])
 
 
 class NonMaxSuppressionWithOverlaps(Primitive):
-    """
-    Greedily selects a subset of bounding boxes in descending order of score.
+    r"""
+    Selects a subset of bounding boxes in a greedy manner by prioritizing those with higher
+    scores and removing those with high overlaps with previously selected boxes.
+    Boxes with scores lower than the score threshold are also removed.
+    The overlap values between boxes are represented as an N-by-N square matrix,
+    which can be customized to define different overlap criteria such as intersection
+    over union or intersection over area.
+
 
     Note:
-        This algorithm is agnostic to where the origin is in the coordinate system.
-        This algorithm is invariant to orthogonal transformations and translations of the coordinate system;
-        thus translating or reflections of the coordinate system result in the same boxes being
-        selected by the algorithm.
+        - This algorithm does not depend on the location of the origin in the coordinate system.
+        - This algorithm remains unaffected by orthogonal transformations and translations of
+          the coordinate system, which means that translating or reflecting the coordinate system
+          will result in the same boxes being chosen by the algorithm.
 
     Inputs:
-        - **overlaps** (Tensor) - A 2-D Tensor of shape [num_boxes, num_boxes].
-          Types allowed:float32.
-        - **scores** (Tensor) - A 1-D Tensor of shape [num_boxes] representing a single score
-          corresponding to each box (each row of boxes),the num_boxes of "scores" must be equal to
-          the num_boxes of "overlaps".
-          Types allowed:float32.
+        - **overlaps** (Tensor) - A 2-D Tensor of shape :math:`(num\_boxes, num\_boxes)`,
+          representing the n-by-n box overlap values. Types allowed:float16, float32 and float64.
+        - **scores** (Tensor) - A 1-D Tensor of shape :math:`(num\_boxes)` where each element represents a
+          single score associated with each box (i.e., each row of the `boxes` Tensor).
+          It is required that the number of scores in `scores` must be equal to the number of boxes in `boxes`.
+          The supported data type is float32.
         - **max_output_size** (Union[Tensor, Number.Int]) - A scalar integer Tensor representing the maximum
           number of boxes to be selected by non max suppression, and max_output_size must be equal to or greater
           than 0.
           Types allowed:int32.
-        - **overlap_threshold** (Union[Tensor, Number.Float]) - A 0-D float tensor representing the threshold for
-          deciding whether boxes overlap too much.
-          Types allowed:float32.
-        - **score_threshold** (Union[Tensor, Number.Float]) - A 0-D float tensor representing the threshold for
-          deciding when to remove boxes based on score.
-          Types allowed:float32.
+        - **overlap_threshold** (Union[Tensor, Number.Float]) - A scalar value, represented by a 0-D float Tensor,
+          which is used as a threshold to determine if two boxes overlap too much.
+          Types allowed:float16, float32 and float64.
+        - **score_threshold** (Union[Tensor, Number.Float]) - A 0-D float Tensor representing the threshold for
+          deciding when to remove boxes based on score. It has the same dtype as `overlap_threshold`.
 
     Outputs:
-        An int32 tensor. A 1-D integer Tensor of shape [M] representing the selected indices from the boxes tensor,
-        where M <= max_output_size.
+       A 1-D integer Tensor of shape :math:`(M)` representing the selected indices from the `boxes` Tensor,
+       where M <= `max_output_size`. Its data type is int32.
 
     Raises:
-        TypeError: If the dtype of `overlaps` and `scores` is not float32.
-        TypeError: If the dtype of `overlap_threshold` and `score_threshold` is not float32.
-        TypeError: If `overlaps` is not tensor or its dtype is not float32.
-        TypeError: If `scores` is not tensor or its dtype is not float32.
-        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 float32.
-        TypeError: If `score_threshold` is not tensor or scalar. If its type is not float32.
+        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 `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.
         ValueError: If the size of shape of `overlaps` is not 2 or the second value of its shape
                     is not equal to the first value of its shape.
         ValueError: If the size of shape of `scores` is not 1.
-        ValueError: If each of the size of shape of `max_output_size`, `overlap_threshold`, `score_threshold` is not 0.
+        ValueError: If any of the size of shape of `max_output_size`, `overlap_threshold`, `score_threshold` is not 0.
         ValueError: If `max_output_size` is negative.
         ValueError: If the shape of `scores` is not equal to the shape of the dim0 or dim1 of `overlaps`.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> overlaps = Tensor(np.array([[0.6964692, 0.28613934, 0.22685145, 0.5513148],
-                                [0.71946895, 0.42310646, 0.9807642, 0.6848297],
-                                [0.4809319, 0.39211753, 0.343178, 0.7290497],
-                                [0.43857226, 0.059677895, 0.39804426, 0.7379954]
-                                ]), mstype.float32)
+        ...                     [0.71946895, 0.42310646, 0.9807642, 0.6848297],
+        ...                     [0.4809319, 0.39211753, 0.343178, 0.7290497],
+        ...                     [0.43857226, 0.059677895, 0.39804426, 0.7379954]
+        ...                     ]), mstype.float32)
         >>> scores = Tensor(np.array([0.18249173, 0.17545176, 0.53155136, 0.53182757]), mstype.float32)
         >>> max_output_size = Tensor(4, mstype.int32)
         >>> overlap_threshold = Tensor(0.1, mstype.float32)
@@ -481,15 +503,20 @@ class NonMaxSuppressionWithOverlaps(Primitive):
 
 
 class HSVToRGB(Primitive):
-    """
-    Convert one or more images from HSV to RGB. The format of the image(s) should be NHWC.
+    r"""
+    Transform one single or a batch of images from HSV to RGB color space.
+    Each pixel's HSV value is converted to its corresponding RGB value.
+    Note that the function is only well-defined for input pixel values in the range [0, 1].
+    Image format should be "NHWC".
 
     Inputs:
-        - **x** (Tensor) - The input image must be a 4-D tensor of shape [batch, image_height, image_width, channel].
-          Number of channel must be 3.
-          Types allowed: float16, float32, float64.
+        - **x** (Tensor) - The input image must be a 4-D tensor of shape
+          :math:`(batch, image\_height, image\_width, channel)`.
+          Number of channel must be 3. Types allowed: float16, float32, float64.
+
     Outputs:
-        A 4-D tensor of shape [batch, image_height, image_width, channel] with same type of input.
+        A 4-D tensor of shape :math:`(batch, image\_height, image\_width, channel)`
+        with same type of input.
 
     Raises:
         TypeError: If `x` is not a Tensor.
@@ -498,7 +525,7 @@ class HSVToRGB(Primitive):
         ValueError: If the last dimension of `x` is not equal to 3.
 
     Supported Platforms:
-        ``CPU``
+        ``GPU`` ``CPU``
 
     Examples:
         >>> image = np.array([0.5, 0.5, 0.5]).astype(np.float32).reshape([1, 1, 1, 3])
@@ -586,27 +613,27 @@ class CropAndResizeGradBoxes(Primitive):
 
 class RGBToHSV(Primitive):
     """
-    Convert one or more images from RGB to HSV.
-    Outputs a tensor of the same shape as the images tensor, containing the HSV value of the pixels.
-    The output is only well defined if the value in images are in [0,1].
+    Transform one single or a batch of images from RGB to HSV color space.
+    Each pixel's RGB value is converted to its corresponding HSV value.
+    Note that the function is only well-defined for input pixel values in the range [0, 1].
 
     Note:
         Last dimension of input images must be size 3.
 
     Inputs:
-        **images** (Tensor) - Must be one of the following types: float16, float32, float64. 1-D or higher rank.
-        RGB data to convert. Last dimension must be size 3.
+        - **images** (Tensor) - 1-D or higher rank RGB data Tensor to convert, last dimension must be size 3.
+          Must be one of the following types: float16, float32, float64.
 
     Outputs:
         A Tensor, has the same type and shape as input `images`.
 
     Raises:
-        TypeError: If `images` is not tensor or its dtype is not float or double.
-        ValueError: If the size of shape of `images` is less than 1.
+        TypeError: If `images` is not tensor or its dtype is not float.
+        ValueError: If the rank of `images` is less than 1.
         ValueError: If the last value of shape of `images` is not 3.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> images =  np.array([0.25, 0.5, 0.5]).astype(np.float32).reshape([1, 1, 1, 3])
@@ -626,37 +653,39 @@ class ResizeLinear1D(Primitive):
     r"""
     Using the linear interpolate method resize the input tensor 'x'.
 
-    For general resize, refer to :func:`mindspore.ops.interpolate` for more detail.
+    For general resize, refer to :func:`mindspore.ops.interpolate` for more details.
 
     .. warning::
-        This is an experimental feature and is subjected to change.
+        - This is an experimental API that is subject to change.
+        - Currently, the Ascend platform only supports scenarios where the input `size` is Tuple or List.
 
     Args:
-        coordinate_transformation_mode (string): 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', 'asymmetric'.
+        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.
-        - **size** (Tensor) - A 1-D int64 Tensor, describes the size of the output tensor.
+        - **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)`.
 
     Outputs:
         A 3-D tensor which shape is [batch, channel, new_width] with the same type as `x`.
 
     Raises:
         TypeError: If dtype of `x` is not in the support list.
-        TypeError: If `size` is not a 1-D int64_t tensor.
+        TypeError: If `size` is not in Union[Tuple[int], List[int], Tensor[int]].
         TypeError: If `coordinate_transformation_mode` is not a string.
         TypeError: If `coordinate_transformation_mode` is not in the support list.
 
     Supported Platforms:
-        ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> input = Tensor([[[1, 2, 3], [4, 5, 6]]], mindspore.float32)
-        >>> size = Tensor([6], mindspore.int32)
+        >>> x = Tensor([[[1, 2, 3], [4, 5, 6]]], mindspore.float32)
+        >>> size = (6,)
         >>> resize_linear_1d = ops.ResizeLinear1D(coordinate_transformation_mode="align_corners")
-        >>> output = resize_linear_1d(x=input, size=size)
+        >>> output = resize_linear_1d(x, size)
         >>> print(output)
         [[[1. 1.4 1.8 2.2 2.6 3.]
           [4. 4.4 4.8 5.2 5.6 6.]]]
@@ -668,7 +697,7 @@ class ResizeLinear1D(Primitive):
         self.init_prim_io_names(inputs=["x", "sizes"], outputs=["output"])
         validator.check_value_type(
             "coordinate_transformation_mode", coordinate_transformation_mode, [str], self.name)
-        validator.check_string(coordinate_transformation_mode, ["align_corners", "half_pixel", "asymmetric"],
+        validator.check_string(coordinate_transformation_mode, ["align_corners", "half_pixel"],
                                "coordinate_transformation_mode", self.name)
 
 
@@ -678,11 +707,14 @@ class ResizeBilinearV2(Primitive):
 
     The resizing only affects the lower two dimensions which represent the height and width.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Args:
-        align_corners (bool): If true, rescale input by :math:`(new\_height - 1) / (height - 1)`,
+        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): Whether half pixel center. If set to True, `align_corners` should be False.
+        half_pixel_centers (bool, optional): Whether half pixel center. If set to True, `align_corners` should be False.
                            Default: False.
 
     Inputs:
@@ -700,13 +732,16 @@ class ResizeBilinearV2(Primitive):
         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.
+        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.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]]], mindspore.float32)
-        >>> output = ops.ResizeBilinearV2(x, (5, 5))
+        >>> output = ops.ResizeBilinearV2()(x, (5, 5))
         >>> print(output)
         [[[[1. 2. 3. 4. 5.]
            [1. 2. 3. 4. 5.]
@@ -725,46 +760,42 @@ class ResizeBilinearV2(Primitive):
                                                              half_pixel_centers, [bool], self.name)
         if half_pixel_centers and align_corners:
             raise ValueError(f"If half_pixel_centers is True, align_corners must be False, but got {align_corners}")
-        target = context.get_context("device_target")
-        if half_pixel_centers and target == "CPU":
-            raise ValueError(f"Currently `half_pixel_centers`=True is not supported in CPU device_target")
 
 
 class ResizeBicubic(Primitive):
-    """
+    r"""
     Resize images to size using bicubic interpolation.
 
-    .. warning::
-        The max output length is 1000000.
-
     Args:
-        align_corners (bool):If true, the centers of the 4 corner pixels of the input
+        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): An optional bool. 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 [batch, height, width, channels].
-          The format must be NHWC.
+        - **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: int32.
+
     Outputs:
-        A 4-D tensor of shape [batch, new_height, new_width, channels] with type: float32.
+        A 4-D tensor of shape :math:`(batch, channels, new\_height, new\_width)` with type float32.
 
     Raises:
         TypeError: If `images` type is not allowed.
-        TypeError: If `size` type is not allowed.
-        TypeError: If `align_corners` type is not allowed.
-        TypeError: If `half_pixel_centers` 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 `size` value is not positive.
-        ValueError: If `align_corners` and `half_pixel_centers` value are both true.
+        ValueError: If any `size` value is not positive.
+        ValueError: If `align_corners` and `half_pixel_centers` value are both True.
 
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> class NetResizeBicubic(nn.Cell):
@@ -791,7 +822,6 @@ class ResizeBicubic(Primitive):
     @prim_attr_register
     def __init__(self, align_corners=False, half_pixel_centers=False):
         """Initialize"""
-        self.add_prim_attr("max_length", 1000000)
         validator.check_value_type('align_corners', align_corners, bool, self.name)
         validator.check_value_type('half_pixel_centers', half_pixel_centers, bool, self.name)
         self.init_prim_io_names(inputs=['images', 'size'], outputs=['y'])
@@ -815,59 +845,61 @@ class ResizeBicubic(Primitive):
                                             mstype.float32, mstype.uint8, mstype.uint16, mstype.double], self.name)
         validator.check_tensor_dtype_valid("size", size_dtype, [mstype.int32], self.name)
         # check input shape rank
-        validator.check("images rank", len(images_shape), "expected", 4, Rel.EQ, self.name)
-        validator.check("size rank", len(size_shape), "expected", 1, Rel.EQ, self.name)
-        validator.check("size dim_0", size_shape[0], "expected", 2, Rel.EQ, self.name)
+        validator.check("images rank", len(images_shape), "expected", 4, validator.EQ, self.name)
+        validator.check("size rank", len(size_shape), "expected", 1, validator.EQ, self.name)
+        validator.check("size dim_0", size_shape[0], "expected", 2, validator.EQ, self.name)
         # check size_value
-        validator.check("size[0]", size_value[0], "minimum", 0, Rel.GT, self.name)
-        validator.check("size[1]", size_value[1], "minimum", 0, Rel.GT, self.name)
+        validator.check("size[0]", size_value[0], "minimum", 0, validator.GT, self.name)
+        validator.check("size[1]", size_value[1], "minimum", 0, validator.GT, self.name)
 
         batch_size = images_shape[0]
+        channel = images_shape[1]
         height = size_value[0]
         width = size_value[1]
-        channel = images_shape[3]
-        out_shape = (batch_size, height, width, channel)
-        return {'shape': out_shape,
-                'dtype': mstype.float32,
-                'value': None}
+
+        out_shape = (batch_size, channel, height, width)
+        return {'shape': out_shape, 'dtype': mstype.float32, 'value': None}
 
 
 class ResizeArea(Primitive):
-    """
+    r"""
     Resize images to a certain size using area interpolation.
 
     The resizing process only changes the two dimensions of images, which represent the width and height of images.
 
     .. warning::
-        The values of "size" must be greater than zero.
+        The values of `size` must be greater than zero.
 
     Args:
-        align_corners (bool): If true, the centers of the 4 corner pixels of the input and output tensors are aligned,
-            preserving the values at the corner pixels. Defaults： False.
+        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
+            with the corner pixels of the input tensor, which preserves the values at the corner pixels.
+            Defaults: False.
 
     Inputs:
-        - **images** (Tensor) -  Input images must be a 4-D tensor with shape which is [batch, height, width, channels].
-          The format must be NHWC.
+        - **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.
 
     Outputs:
-        A 4-D tensor of shape [batch, new_height, new_width, channels] with type: float32.
+        A 4-D tensor of shape :math:`(batch, new\_height, new\_width, channels)` with type float32.
 
     Raises:
         TypeError: If dtype of `images` is not supported.
         TypeError: If dtype of `size` is not int32.
         TypeError: If dtype of `align_corners` is not bool.
         ValueError: If the num of inputs is not 2.
-        ValueError: If the dimension of `images` shape is not 4.
-        ValueError: If the dimension of `size` shape is not 1.
-        ValueError: If the element num of `size` is not [new_height, new_width].
-        ValueError: The size is not positive.
+        ValueError: If the dimension of `images` is not 4.
+        ValueError: If the dimension of `size` is not 1.
+        ValueError: If the element num of `size` is not 2.
+        ValueError: If any value of `size` is not positive.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> images = Tensor([[[[2], [4], [6], [8]], [[10], [12], [14], [16]]]], mindspore.float16)
@@ -896,7 +928,7 @@ class CropAndResizeGradImage(Primitive):
 
     Args:
         method (str): A string specifying the interpolation method. "bilinear", "nearest" and "bilinear_v2" are
-            supported for now. Default: "bilinear".
+            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}.
 
@@ -928,7 +960,7 @@ class CropAndResizeGradImage(Primitive):
         TypeError: If `box_index` is not tensor or its dtype is not int32.
         TypeError: If `image_size` is not tensor or its dtype is not int32.
         TypeError: If the value of `T` is not a number dtype in mindspore.
-        ValueError: If `method` is not "bilinear".
+        ValueError: If `method` is not in {"bilinear", "nearest", "bilinear_v2"}.
         ValueError: If `T` is not in {mindspore.float16, mindspore.float32, mindspore.float64}.
         ValueError: If the size of `grads` tensor shape is not equal to 4.
         ValueError: If the size of `boxes` tensor shape is not equal to 2.
@@ -939,7 +971,7 @@ class CropAndResizeGradImage(Primitive):
         ValueError: If the value of image_height or image_width of `image_size` is not positive.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> crop_and_resize_grad_image = ops.CropAndResizeGradImage(T = mindspore.float32, method = "bilinear")
@@ -972,39 +1004,46 @@ class CropAndResizeGradImage(Primitive):
         """Initialize CropAndResizeGradImage"""
         self.init_prim_io_names(inputs=['grads', 'boxes', 'box_index', 'image_size'], outputs=['y'])
         validator.check_value_type("method", method, [str], self.name)
-        validator.check_string(method, ["bilinear", "nearest", "bilinear_v2"], "method", self.name)
+        is_ascend_cpu = context.get_context('device_target') in ("Ascend", "CPU")
+        if is_ascend_cpu:
+            validator.check("method", method, "expected", ("bilinear", "nearest"), validator.IN, self.name)
+        else:
+            validator.check("method", method, "expected", ("bilinear", "nearest", "bilinear_v2"),
+                            validator.IN, self.name)
         self.method = method
         valid_values = (mstype.float16, mstype.float32, mstype.float64)
         if T in mstype.number_type:
-            validator.check("T", T, "expected", valid_values, Rel.IN, self.name)
+            validator.check("T", T, "expected", valid_values, validator.IN, self.name)
         else:
             validator.check_type_name("T", T, valid_values, self.name)
         self.add_prim_attr("max_Byte", int(2e9))  # Maximum bytes of image gradient
 
 
 class ScaleAndTranslate(Primitive):
-    """
+    r"""
     Scale And Translate the input image tensor.
 
     Note:
-        Input images must be a 4-D tensor.
-        Input size, scale and translation must be a 1-D tensor with two elements.
+        - Input images must be a 4-D tensor.
+        - Input size, scale and translation must be a 1-D tensor with two elements.
 
     Args:
-        kernel_type (str): An optional string. Deciding which image filtering algorithm to choose. Default: "lanczos3".
-        antialias (bool): An optional bool. Deciding whether to use the antialias. Default: True.
+        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.
 
     Inputs:
-        - **images** (Tensor) - A 4-D tensor of shape (batch, image_height, image_width, channel).
+        - **images** (Tensor) - A 4-D tensor of shape :math:`(batch, image\_height, image\_width, channel)`.
         - **size** (Tensor) - The size of the output image after scale and translate operations. A 1-D tensor with two
-          positive elements whose dtype is int32 and shape must be (2,).
+          positive elements whose dtype is int32 and shape must be :math:`(2,)`.
         - **scale** (Tensor) - Indicates the zoom factor. A 1-D tensor with two positive elements whose dtype is float32
-          and shape must be (2,).
+          and shape must be :math:`(2,)`.
         - **translation** (Tensor) - Translate the pixel value. A 1-D tensor with two elements whose dtype is
-          float32 and shape must be (2,).
+          float32 and shape must be :math:`(2,)`.
 
     Outputs:
-        A 4-D tensor with type: float32 and shape: [batch, size[0], size[1], channel].
+        A 4-D tensor with type: float32 and shape :math:`(batch, size[0], size[1], channel)`.
 
     Raises:
         TypeError: If `kernel_type` is not str.
@@ -1016,9 +1055,9 @@ class ScaleAndTranslate(Primitive):
         ValueError: If `kernel_type` is not in ["lanczos1", "lanczos3", "lanczos5", "gaussian", "box", "triangle",
                     "keyscubic", "mitchellcubic"].
         ValueError: If the rank of `images` is not 4.
-        ValueError: If  the shape of `size` is not (2,).
-        ValueError: If  the shape of `scale` is not (2,).
-        ValueError: If the shape of `translation`  is not (2,).
+        ValueError: If the shape of `size` is not :math:`(2,)`.
+        ValueError: If the shape of `scale` is not :math:`(2,)`.
+        ValueError: If the shape of `translation`  is not :math:`(2,)`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1045,3 +1084,159 @@ class ScaleAndTranslate(Primitive):
         validator.check_string(kernel_type, ["lanczos1", "lanczos3", "lanczos5", "gaussian", "box", "triangle",
                                              "keyscubic", "mitchellcubic"], "kernel_type", self.name)
         validator.check_value_type("antialias", antialias, [bool], self.name)
+
+
+class CombinedNonMaxSuppression(Primitive):
+    r"""
+    Applies a greedy approach to select a subset of bounding boxes from a list of
+    candidates using NonMaxSuppression, where the boxes are sorted in descending order of their confidence score.
+
+    Args:
+        clip_boxes (bool, optional): Determines whether to apply bounding box normalization to ensure the
+            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.
+
+        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.
+
+            - 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)`
+          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,
+          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.
+        - **max_total_size** (Tensor) - A scalar Tensor of type int32 that represents the
+          maximum number of boxes that are kept for all classes.
+        - **iou_threshold** (Tensor) - A scalar Tensor of float32 type that represents the threshold for
+          determining if the IOU overlap between boxes is too high. `iou_threshold` must be equal or greater
+          than 0 and be equal or smaller than 1.
+        - **score_threshold** (Tensor) - A scalar Tensor of type float32 that represents the threshold
+          for determining when to remove boxes based on their scores.
+
+    Outputs:
+        - **nmsed_boxes** - A Tensor of float32 with shape of (batch_size, num_detection, 4), which contains
+          the non-max suppressed boxes.
+        - **nmsed_scores** - A Tensor of float32 with shape of (batch_size, num_detection), which contains score
+          of boxes.
+        - **nmsed_classes** - A Tensor of float32 with shape of (batch_size, num_detection), which contains classes
+          of boxes.
+        - **valid_detections** A Tensor of int32 with shape of (batch_size,), which indicates the number of valid
+          detections of each batch.
+
+    Raises:
+        TypeError: If the dtype of `boxes`, `scores` , `iou_threshold` , `score threshold` are not float32.
+        TypeError: If the dtype of `max_output_size_per_class` and `max_total_size` are not int32.
+        ValueError: If `boxes` is not 4D.
+        ValueError: If `max_output_size_per_class`, `max_total_size`, `iou_threshold` and `score threshold` are not 0D.
+        ValueError: If `scores` is not 3D.
+        ValueError: If shape[0] or shape[1] of `boxes` is not same with that of the `scores`.
+        ValueError: If shape[2] of `boxes` is not same with shape[2] of `scores` or 1
+        ValueError: If `max_total_size` < 0.
+        ValueError: If `max_output_size_per_class` < 0.
+        ValueError: If `iou_threshold` not in [0,1].
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> boxes = Tensor(np.array([[[[200, 100, 150, 100]],
+        ...                           [[220, 120, 150, 100]],
+        ...                           [[190, 110, 150, 100]],
+        ...                           [[210, 112, 150, 100]]]])).astype('float32')
+        >>> scores = Tensor(np.array([[[0.2000, 0.7000, 0.1000], [0.1000, 0.8000, 0.1000], [0.3000, 0.6000, 0.1000],
+        ...                            [0.0500, 0.9000, 0.0500]]])).astype('float32')
+        >>> max_output_size_per_class = Tensor(4, mstype.int32)
+        >>> max_total_size = Tensor(1, mstype.int32)
+        >>> iou_threshold = Tensor(0, mstype.float32)
+        >>> score_threshold = Tensor(0, mstype.float32)
+        >>> net = ops.CombinedNonMaxSuppression()
+        >>> out = net(boxes, scores, max_output_size_per_class, max_total_size, iou_threshold, score_threshold)
+        >>> print(out)
+        (Tensor(shape=[1, 1, 4], dtype=Float32, value= [[[1.00000000e+00, 1.00000000e+00, 1.00000000e+00,
+                                                          1.00000000e+00]]]),
+        Tensor(shape=[1, 1], dtype=Float32, value= [[ 8.99999976e-01]]),
+        Tensor(shape=[1, 1], dtype=Float32, value= [[ 1.00000000e+00]]),
+        Tensor(shape=[1], dtype=Int32, value= [1]))
+    """
+
+    @prim_attr_register
+    def __init__(self, pad_per_class=False, clip_boxes=True):
+        """Initialize CombinedNonMaxSuppression"""
+        self.pad_per_class = validator.check_value_type("pad_per_class", pad_per_class, [bool], self.name)
+        self.add_prim_attr('pad_per_class', self.pad_per_class)
+        self.clip_boxes = validator.check_value_type("clip_boxes", clip_boxes, [bool], self.name)
+        self.add_prim_attr('clip_boxes', self.clip_boxes)
+
+
+class ResizeV2(Primitive):
+    r"""
+    Using the nearest, linear or cubic interpolate method resize the input tensor 'x'.
+
+    Note:
+        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'.
+
+    Inputs:
+        - **x** (Tensor) - A 4-D tensor which to resize, with shape [batch, channel, width, height]. Must be one of the
+          following types: uint8, int8, int16, int32, int64, float16, float32, float64, when mode = 'nearest'.
+          Must be one of the following types: float16, float32, float64, when mode = 'linear' or 'cubic'.
+        - **roi** (Tensor) - A 1-D float32 Tensor. Unused parameters currently.
+        - **scales** (Tensor) - A 1-D float32 Tensor. Unused parameters currently.
+        - **sizes** (Tensor) - A 1-D int64 or int32 Tensor, the length must be 4 and greater than 0.
+          And sizes[0], sizes[1] must match with the shape[0] and shape[1] of x.
+          When mode equals 'nearest' or 'linear', sizes[2] must be 1.
+
+    Outputs:
+        A 4-D tensor which shape is [batch, channel, new_height, new_width] with type as same as x.
+
+    Raises:
+        TypeError: If dtype of `x`, `roi`, `scales` or `sizes` is not supported.
+        ValueError: If shape of `x`, `roi`, `scales` or `sizes` is not supported.
+        ValueError: If the length of `sizes` is not 4.
+        ValueError: If `sizes` is not greater than 0.
+        ValueError: If sizes[2] is not 1, when `mode` = 'nearest' or 'linear'.
+        ValueError: If sizes[0] and sizes[1] don't match the shape[0] and shape[1] of x.
+        ValueError: If `coordinate_transformation_mode` or `mode` is not supported.
+        ValueError: If `coordinate_transformation_mode` is not 'half_pixel', when `mode` = 'nearest'.
+
+    Supported Platforms:
+        ``CPU``
+
+    Examples:
+        >>> x = Tensor(np.array([[[[1., 2., 3., 4.]]]]).astype(np.float32))
+        >>> roi = Tensor(np.array([0]).astype(np.float32))
+        >>> scales = Tensor(np.array([0]).astype(np.float32))
+        >>> sizes = Tensor(np.array([1, 1, 1, 9]).astype(np.int64))
+        >>> resize_v2 = ops.ResizeV2(coordinate_transformation_mode="half_pixel", mode="nearest")
+        >>> output = resize_v2(x, roi, scales, sizes)
+        >>> print(output)
+        [[[[1. 1. 1. 2. 2. 3. 3. 4. 4.]]]]
+    """
+    @prim_attr_register
+    def __init__(self, coordinate_transformation_mode="half_pixel", mode="nearest"):
+        """Initialize ResizeV2."""
+        self.init_prim_io_names(inputs=['x', 'roi', 'scales', 'sizes'], outputs=['y'])
+        self.add_prim_attr("nearest_mode", "floor")
+        self.add_prim_attr("cubic_coeff_a", -0.75)
+        validator.check_value_type(
+            "coordinate_transformation_mode", coordinate_transformation_mode, [str], self.name)
+        validator.check_string(coordinate_transformation_mode, ["align_corners", "half_pixel"],
+                               "coordinate_transformation_mode", self.name)
+        validator.check_value_type("mode", mode, [str], self.name)
+        validator.check_string(mode, ["nearest", "linear", "cubic"], "mode", self.name)