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

mindspore/ops/operations/image_ops.py

@@ -17,8 +17,7 @@
 
 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
 
@@ -34,8 +33,11 @@ class AdjustSaturation(Primitive):
 
     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.
+          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.
 
     Outputs:
         Adjusted image(s), same shape and dtype as `image`.
@@ -48,7 +50,7 @@ class AdjustSaturation(Primitive):
         ValueError: If the last dimension of the 'image' is not 3.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
       >>> x = Tensor([[[1.0, 2.0, 3.0],
@@ -96,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:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
     >>> images = Tensor([[[1.0, 2.0, 3.0],
@@ -131,8 +133,9 @@ 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.
 
     Outputs:
@@ -145,7 +148,7 @@ class AdjustHue(Primitive):
         ValueError: If the dimension of `image` is less than 3.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
          >>> class AdjustHue(nn.Cell):
@@ -178,10 +181,11 @@ 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, optional): An optional `bool`. Indicates if the offset coordinates
@@ -191,28 +195,29 @@ class ExtractGlimpse(Primitive):
         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 or a Gaussian distribution. Defaults to `True`.
-        noise (str, optional): An optional string. 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'.
-            Defaults to `uniform`.
+            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.
@@ -225,7 +230,7 @@ class ExtractGlimpse(Primitive):
         ValueError: If the input is not Tensor.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> x = Tensor([[[[0.0], [1.0], [2.0]], [[3.0], [4.0], [5.0]], [[6.0], [7.0], [8.0]]]], dtype=mindspore.float32)
@@ -262,7 +267,7 @@ class ExtractGlimpse(Primitive):
 
 
 class CropAndResize(Primitive):
-    """
+    r"""
     Extracts crops from the input image tensor and resizes them.
 
     Note:
@@ -276,9 +281,10 @@ 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
@@ -286,14 +292,14 @@ class CropAndResize(Primitive):
           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
           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).
+        - **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.
@@ -352,39 +358,42 @@ 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.
 
     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 :math:`(num\_boxes, 4)`.
-        - **scores** (Tensor) - A 1-D Tensor of shape :math:`(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`.
+        - **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` 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 `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.
@@ -394,7 +403,7 @@ class NonMaxSuppressionV3(Primitive):
             `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],
@@ -412,46 +421,54 @@ 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):
     r"""
-    Greedily selects a subset of bounding boxes in descending order of score.
+    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 :math:`(num\_boxes, num\_boxes)`,
-          representing the n-by-n box overlap values. Types allowed:float32.
-        - **scores** (Tensor) - A 1-D Tensor of shape :math:`(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.
+          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.
+        - **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.
-          Types allowed:float32.
+          deciding when to remove boxes based on score. It has the same dtype as `overlap_threshold`.
 
     Outputs:
-       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.
+       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` , `scores` `overlap_threshold` and `score_threshold` 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 float32.
-        TypeError: If `score_threshold` is not Tensor or scalar. If its type is not float32.
+        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.
@@ -460,14 +477,14 @@ class NonMaxSuppressionWithOverlaps(Primitive):
         ValueError: If the shape of `scores` is not equal to the shape of the dim0 or dim1 of `overlaps`.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``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)
@@ -487,18 +504,18 @@ class NonMaxSuppressionWithOverlaps(Primitive):
 
 class HSVToRGB(Primitive):
     r"""
-    Convert one or more images from HSV to RGB.
-    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 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
-          :math:`[batch, image\_height, image\_width, channel]`.
+          :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 :math:`[batch, image\_height, image\_width, channel]`
+        A 4-D tensor of shape :math:`(batch, image\_height, image\_width, channel)`
         with same type of input.
 
     Raises:
@@ -569,7 +586,7 @@ class CropAndResizeGradBoxes(Primitive):
         ValueError: If the length of `box_index` is not equal to num_boxes.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> crop_and_resize_grad_boxes = ops.CropAndResizeGradBoxes(method = "bilinear")
@@ -596,9 +613,9 @@ 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.
@@ -611,12 +628,12 @@ class RGBToHSV(Primitive):
         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.
+        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:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> images =  np.array([0.25, 0.5, 0.5]).astype(np.float32).reshape([1, 1, 1, 3])
@@ -639,34 +656,36 @@ class ResizeLinear1D(Primitive):
     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.]]]
@@ -678,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)
 
 
@@ -689,7 +708,7 @@ class ResizeBilinearV2(Primitive):
     The resizing only affects the lower two dimensions which represent the height and width.
 
     .. warning::
-        On CPU, setting `half_pixel_centers` to True is currently not supported.
+        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)`,
@@ -718,7 +737,7 @@ class ResizeBilinearV2(Primitive):
         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)
@@ -741,18 +760,12 @@ 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, 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.
@@ -760,14 +773,14 @@ class ResizeBicubic(Primitive):
             `align_corners` should be False. Default: False.
 
     Inputs:
-        - **images** (Tensor) - The input image must be a 4-D tensor of shape :math:`(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 :math:`(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.
@@ -780,8 +793,9 @@ class ResizeBicubic(Primitive):
         ValueError: If any `size` value is not positive.
         ValueError: If `align_corners` and `half_pixel_centers` value are both True.
 
+
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> class NetResizeBicubic(nn.Cell):
@@ -808,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'])
@@ -832,21 +845,20 @@ 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):
@@ -859,12 +871,15 @@ class ResizeArea(Primitive):
         The values of `size` must be greater than zero.
 
     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. 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 :math:`(batch, channels, height, width)`. The format must be NHWC.
+          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.
@@ -884,7 +899,7 @@ class ResizeArea(Primitive):
         ValueError: If any value of `size` is not positive.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> images = Tensor([[[[2], [4], [6], [8]], [[10], [12], [14], [16]]]], mindspore.float16)
@@ -956,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`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> crop_and_resize_grad_image = ops.CropAndResizeGradImage(T = mindspore.float32, method = "bilinear")
@@ -991,13 +1006,14 @@ class CropAndResizeGradImage(Primitive):
         validator.check_value_type("method", method, [str], self.name)
         is_ascend_cpu = context.get_context('device_target') in ("Ascend", "CPU")
         if is_ascend_cpu:
-            validator.check("method", method, "expected", ("bilinear", "nearest"), Rel.IN, self.name)
+            validator.check("method", method, "expected", ("bilinear", "nearest"), validator.IN, self.name)
         else:
-            validator.check("method", method, "expected", ("bilinear", "nearest", "bilinear_v2"), Rel.IN, self.name)
+            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
@@ -1020,11 +1036,11 @@ class ScaleAndTranslate(Primitive):
     Inputs:
         - **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 :math:`(batch, size[0], size[1], channel)`.
@@ -1044,7 +1060,7 @@ class ScaleAndTranslate(Primitive):
         ValueError: If the shape of `translation`  is not :math:`(2,)`.
 
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> op = ops.ScaleAndTranslate()
@@ -1072,33 +1088,41 @@ class ScaleAndTranslate(Primitive):
 
 class CombinedNonMaxSuppression(Primitive):
     r"""
-    Greedily selects a subset of bounding boxes in descending order of score.
+    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): If true, assume the box coordinates are between [0, 1] and clip the output boxes
-            if they fall beyond [0, 1]. If false, do not do clipping and output the box coordinates as it is.
-            Defaults to true.
-        pad_per_class (bool, optional): If false, the output nmsed boxes, scores and classes are padded/clipped
-            to max_total_size.
-            If true, the output nmsed boxes, scores and classes are padded to be of length
-            max_size_per_class * num_classes, unless it exceeds max_total_size in which case it is clipped to
-            max_total_size. Defaults to false.
+        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 Tensor of type float32 and shape (batch_size, num_boxes, q, 4).
-          If q is 1 then same boxes are used for all classes otherwise,
-          if q is equal to number of classes, class-specific boxes are used.
-        - **scores** (Tensor) - A Tensor of type float32 and shape (batch_size, num_boxes, num_classes)
-          representing a single score corresponding to each box (each row of boxes).
-        - **max_output_size_per_class** (Tensor) - A 0D Tensor of type int32, representing the max number of boxes to be
-          selected by non max suppression per class.
-        - **max_total_size** (Tensor) - A 0D Tensor of type int32, representing the maximum number of boxes retained
-          over all classes.
-        - **iou_threshold** (Tensor) - A 0D float32 tensor representing the threshold for deciding whether
-          boxes overlap too much with respect to IOU, and iou_threshold must be equal or greater
+        - **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 0D float32 tensor representing the threshold for deciding when to remove
-          boxes based on score.
+        - **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
@@ -1123,7 +1147,7 @@ class CombinedNonMaxSuppression(Primitive):
         ValueError: If `iou_threshold` not in [0,1].
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> boxes = Tensor(np.array([[[[200, 100, 150, 100]],
@@ -1153,3 +1177,66 @@ class CombinedNonMaxSuppression(Primitive):
         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)