!48082 refactor interpolate

Merge pull request !48082 from DavidFFFan/api_interpolate

.jenkins/check/config/whitelizard.txt

@@ -29,6 +29,7 @@ mindspore/model_zoo/official/recommend/wide_and_deep_multitable/src/wide_and_dee
 mindspore/mindspore/ccsrc/pipeline/jit/resource.cc:mindspore::pipeline::GetMethodMap
 mindspore/mindspore/python/mindspore/ops/operations/array_ops.py:_compute_slicing_shape
 mindspore/mindspore/python/mindspore/ops/function/array_func.py:scatter_nd
+mindspore/mindspore/python/mindspore/ops/function/nn_func.py:interpolate
 mindspore/mindspore/python/mindspore/ops/function/nn_func.py:max_unpool3d
 mindspore/mindspore/python/mindspore/ops/function/nn_func.py:max_unpool2d
 mindspore/mindspore/python/mindspore/ops/function/nn_func.py:max_unpool1d

docs/api/api_python/ops/mindspore.ops.func_interpolate.rst

@@ -1,36 +1,61 @@
 mindspore.ops.interpolate
 =========================
 
-.. py:function:: mindspore.ops.interpolate(x, roi=None, scales=None, sizes=None, coordinate_transformation_mode="align_corners", mode="linear")
+.. py:function:: mindspore.ops.interpolate(x, size=None, scale_factor=None, mode="nearest", align_corners=None, recompute_scale_factor=None)
 
-    使用 `mode` 设置的插值方式调整输入 `x` 大小。
+    按照给定的 `size` 或 `scale_factor` 根据 `mode` 设置的插值方式，对输入 `x` 调整大小。
-
-    .. warning::
-        - 实验特性，接口可能发生变化。
-        - `roi` 是保留输入， `crop_and_resize` 坐标变换模式下生效，当前不支持。
-        - Ascend平台下，当前不支持将 `mode` 设置为"linear"。
 
     参数：
-        - **x** (Tensor) - 输入Tensor。当 `mode` 是"linear"时， `x` 为三维Tensor。当 `mode` 是"bilinear"时， `x` 为四维Tensor。
+        - **x** (Tensor) - 被调整大小的Tensor。输入向量必须为3维，4维或5维，形状为 `(batch, channels, [optional depth], [optional height], width)` ，数据类型为float。
-        - **roi** (tuple[float]，可选) - 在 `crop_and_resize` 坐标变换模式下生效，当前不支持。
+        - **size** (Union[int, tuple[int], list[int]], 可选) - 目标大小。如果 `size` 为tuple或list，那么其长度应该和 `x` 维度相同。 `size` 和 `scale_factor` 同时只能指定一个。默认值：None。
-        - **scales** (tuple[float]，可选) - 输入shape每个维度resize的系数。 `scales` 中的数全是正数。 `scales` 的长度跟 `x` 的shape长度相同。 `scales` 和 `sizes` 同时只能指定一个。
+        - **scale_factor** (Union[float, tuple[float], list[float]]，可选) - 每个维度的缩放系数。 `scales` 中的数全是正数。 `size` 和 `scale_factor` 同时只能指定一个。默认值：None。
-        - **sizes** (tuple[int]，可选) - 输入shape指定轴的新维度。 `sizes` 中的数全是正数。 `scales` 和 `sizes` 同时只能指定一个。当 `mode` 是"linear"时， `sizes` 为1个int元素 :math:`(new\_width,)` 的tuple。当 `mode` 是"bilinear"时， `sizes` 为2个int元素 :math:`(new\_height, new\_width)` 的tuple。
+        - **mode** (str) - 采样算法。以下采样方式的一种，'nearest', 'linear' (仅三维)，'bilinear' (仅四维)，'bicubic' (仅四维)，'trilinear' (仅五维)，'area'，'nearest-exact'(三维和四维)。默认值：'nearest'。
-        - **coordinate_transformation_mode** (str) - 指定进行坐标变换的方式，默认值是"align_corners"，还可选"half_pixel"和"asymmetric"。
+        - **align_corners** (bool) - 如果为True，缩放比例系数使用 `(new\_height - 1) / (height - 1)` 计算，此种方式调整的数据与原始数据边角对齐。如果为False，缩放系数通过 `new\_height / height` 计算。
-          假如我们需要将输入Tensor的x轴进行resize。我们记 `new_i` 为resize之后的Tenosr沿x轴的第i个坐标；记 `old_i` 为输入Tensor沿x轴的对应坐标；
-          记 `new_length` 是resize之后的Tensor沿着x轴的长度，记 `old_length` 是输入Tensor沿x轴的长度。我们可以通过下面的公式计算出来 `old_i` ：
 
           .. code-block::
 
-              old_i = new_length != 1 ? new_i * (old_length - 1) / (new_length - 1) : 0  # if set to 'align_corners'
+              old_i = new_length != 1 ? new_i * (old_length - 1) / (new_length - 1) : 0  # 'align_corners' 为 True
+              old_i = new_length > 1 ? (new_x + 0.5) * old_length / new_length - 0.5 : 0  # 'align_corners' 为 False
 
-              old_i = new_length > 1 ? (new_x + 0.5) * old_length / new_length - 0.5 : 0  # if set to 'half_pixel'
+          此选项只对'linear'、'bilinear'、'bicubic'和'trilinear'模式有效。默认值：False。
+        - **recompute_scale_factor** (bool, 可选) - 重计算 `scale_factor` 。如果为True，会使用参数 `scale_factor` 计算参数 `size`，最终使用 `size` 的值进行缩放。如果为False，将使用 `size` 或 `scale_factor` 直接进行插值。默认值：None。
 
-              old_i = new_length != 0 ? new_i * old_length / new_length : 0  # if set to 'asymmetric'
+    参数支持列表和支持平台：
 
-        - **mode** (str) - 所使用的插值方式。目前支持"linear"和"bilinear"插值方式。默认值："linear"。
+    +----------------+------+----------------+---------------+------------------+
+    | mode           | dim  | align_corners  | scale_factor  | device           |
+    +================+======+================+===============+==================+
+    | nearest        | 3    | \-             | ×             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 4    | \-             | ×             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 5    | \-             | √             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | linear         | 3    | √              | ×             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | bilinear       | 4    | √              | ×             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    | trilinear      | 5    | √              | √             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | bicubic        | 4    | √              | ×             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | area           | 3    | \-             | √             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 4    | \-             | √             | GPU              |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 5    | \-             | √             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | nearest-exact  | 3    | \-             | ×             | Ascend,CPU       |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 4    | \-             | ×             | Ascend,CPU       |
+    +----------------+------+----------------+---------------+------------------+
+
+    - `-` 表示无此参数。
+    - `×` 表示当前不支持此参数。
+    - `√` 表示当前支持此参数。
 
     返回：
-        Tensor，数据类型与 `x` 相同。
+        调整大小之后的Tensor，维度和数据类型与 `x` 相同。
 
     异常：
         - **TypeError** - `x` 不是Tensor。
@@ -42,4 +67,4 @@ mindspore.ops.interpolate
         - **TypeError** - `coordinate_transformation_mode` 不是string。
         - **ValueError** - `coordinate_transformation_mode` 不在支持的列表中。
         - **TypeError** - `mode` 不是string类型。
-        - **ValueError** - `mode` 不在支持的列表中。
+        - **ValueError** - `mode` 不在支持的列表中。

mindspore/python/mindspore/ops/function/nn_func.py

@@ -15,14 +15,14 @@
 
 """Defines nn operators with functional form."""
 from __future__ import absolute_import
-from math import pi, log
+from math import pi, log, floor
 import numpy as np
 
 import mindspore.ops as ops
+import mindspore.nn as nn
 from mindspore.ops.primitive import constexpr
 from mindspore.ops import operations as P
 from mindspore.ops.operations import nn_ops as NN_OPS
-from mindspore.ops.operations import image_ops as IMG
 import mindspore.common.dtype as mstype
 from mindspore.ops.function.math_func import logsumexp
 from mindspore.common.tensor import Tensor
@@ -1927,160 +1927,249 @@ def hardswish(x):
 
 
 @constexpr
-def _check_interpolate_inputs(input_dims, roi, scales, sizes, coordinate_transformation_mode, mode,
+def _scale_factor_convert_size(shape, scale_factor, dim):
-                              prim_name):
+    return [int(floor(float(shape[i + 2]) * scale_factor[i])) for i in range(dim)]
-    """Check input"""
-    msg_prefix = f"For '{prim_name}', the"
-    validator.check_value_type("coordinate_transformation_mode", coordinate_transformation_mode, [str], prim_name)
-    support_coordinate_mode_list = ["align_corners", "half_pixel", "asymmetric"]
-    if coordinate_transformation_mode not in support_coordinate_mode_list:
-        raise TypeError(f"{msg_prefix} coordinate_transformation_mode must be in {support_coordinate_mode_list},"
-                        f" but got {coordinate_transformation_mode}")
-    validator.check_value_type("mode", mode, [str], prim_name)
-    if mode == "linear":
-        validator.check_int(input_dims, 3, Rel.EQ, "input dims", prim_name)
-    elif mode == "bilinear":
-        validator.check_int(input_dims, 4, Rel.EQ, "input dims", prim_name)
-    else:
-        raise ValueError(f"{msg_prefix} mode must be 'linear' or 'bilinear', but got {mode}")
-
-    if sizes is None and scales is None:
-        raise ValueError(f"{msg_prefix} 'sizes' and 'scale' both none.")
-    if sizes is not None and scales is not None:
-        raise ValueError(f"{msg_prefix} 'sizes' and 'scale' both not none.")
-    if sizes is not None:
-        if not isinstance(sizes, tuple):
-            raise TypeError(
-                f"{msg_prefix} 'sizes' must be tuple or None, but got {type(sizes).__name__}.")
-        for item in sizes:
-            validator.check_positive_int(item, 'sizes item', prim_name)
-            validator.check_value_type("sizes item", item, int, prim_name)
-        validator.check_int(len(sizes), input_dims - 2, Rel.EQ, "sizes", prim_name)
-        return
-    if not isinstance(scales, tuple):
-        raise TypeError(
-            f"{msg_prefix} 'scales' must be tuple or None, but got {type(scales).__name__}.")
-    for item in scales:
-        validator.check_positive_float(item, 'scales item', prim_name)
-        validator.check_value_type("scales item", item, float, prim_name)
-    scales_dims = len(scales)
-    validator.check_int(scales_dims, input_dims, Rel.EQ, "scales dims", prim_name)
-    validator.check_float(scales[0], 1.0, Rel.EQ, "scales[0]", prim_name)
-    validator.check_float(scales[1], 1.0, Rel.EQ, "scales[1]", prim_name)
 
 
-def _interpolate_output_shape(shape, scales, sizes, mode):
+def interpolate(x, size=None, scale_factor=None, mode="nearest", align_corners=None, recompute_scale_factor=None):
-    """calculate output shape"""
-    if sizes is not None:
-        if mode == "bilinear":
-            return sizes
-        return Tensor(sizes)
-    ret = ()
-    for i in range(2, len(shape)):
-        ret = ret + (int(scales[i] * shape[i]),)
-    if mode == "bilinear":
-        return ret
-    return Tensor(ret)
-
-
-def interpolate(x, roi=None, scales=None, sizes=None, coordinate_transformation_mode="align_corners", mode="linear"):
     r"""
-    Using the interpolate method specified by `mode` resize the input tensor `x`.
+    Samples the input Tensor to the given size or scale_factor by using one of the interpolate algorithms.
-
-    .. warning::
-        - This is an experimental prototype that is subject to change.
-        - The `roi` is reserved interface for 'crop_and_resize' coordinate transformation mode,
-          which is not support now.
-        - The Ascend platforms is currently not supported when `mode` is "linear".
 
     Args:
-        x (Tensor): a tensor which to resize. `x` is a 3-D tensor when `mode` is "linear". `x` is a 4-D tensor when
+        x (Tensor): Tensor to be resized.
-            `mode` is "bilinear".
+            Input tensor must be a 3-D, 4-D, or 5-D tensor with shape
-        roi (tuple[float], optional): a tuple of float. Only takes effect when attr coordinate_transformation_mode is
+            `(batch, channels, [optional depth], [optional height], width)`, with data type of float.
-            'crop_and_resize'.
+        size (Union[int, tuple[int], list[int]], optional)): The target size.
-        scales (tuple[float], optional): a tuple of float. Describe the scale along each dimension.
+            If size is a tuple or list, size must have the same dimensions as x.
-            Its length is the same as that of shape of `x`. The numbers in `scales` must all be positive. Only one of
+            One and only one of size and scale_factor can be set to None. Default: None.
-            `scales` and `sizes` can be specified.
+        scale_factor (Union[float, tuple[float], list[float]], optional): The scale factor of new size of the tensor.
-        sizes (tuple[int], optional): a tuple of int, describes the shape of the output tensor. The numbers in `sizes`
+            If size is a tuple or list, size must have the same dimensions as x.
-            must all be positive. Only one of `scales` and `sizes` can be specified.  If `sizes` is specified, then set
+            One and only one of size and scale_factor can be set to None. Default: None.
-            `scales` to 'None' in this operator's input list. It is 1 int elements :math:`(new\_width,)` when `mode`
+        mode (str): The sampling algorithm.
-            is "linear". It is 2 int elements :math:`(new\_height, new\_width)` when `mode` is "bilinear".
+            One of 'nearest', 'linear' (3D only), 'bilinear' (4D only), 'bicubic' (4D only), 'trilinear' (5D only),
-        coordinate_transformation_mode (str): Default is 'align_corners'. Describes how to transform the coordinate
+            'area', 'nearest-exact'(3D and 4D). Default: 'nearest'.
-            in the resized tensor to the coordinate in the original tensor. Other optional: 'half_pixel', 'asymmetric'.
+        align_corners (bool): If True, rescale input by `(new\_height - 1) / (height - 1)`, which exactly
-            For example, we want to resize the original tensor along axis x. Let's denote `new_i` as the i-th coordinate
+            aligns the corners of data and resized data. If False, rescale by `new\_height / height`.
-            of the resized tensor along axis x, `old_i` as the coordinate of the original tensor along axis x,
-            `new_length` as the length of the resized tensor along axis x, `old_length` as the length of the original
-            tensor along axis x. We compute the `old_i` via the following formula:
 
             .. code-block::
 
-                old_i = new_length != 1 ? new_i * (old_length - 1) / (new_length - 1) : 0  # if set to 'align_corners'
+                old_i = new_length != 1 ? new_i * (old_length - 1) / (new_length - 1) : 0  # 'align_corners' = True
+                old_i = new_length > 1 ? (new_x + 0.5) * old_length / new_length - 0.5 : 0  # 'align_corners' = False
 
-                old_i = new_length > 1 ? (new_x + 0.5) * old_length / new_length - 0.5 : 0  # if set to 'half_pixel'
+            This is only valid for 'linear', 'bilinear', 'bicubic', or 'trilinear' modes. Default: False.
+        recompute_scale_factor (bool, optional): Recalculate `scale_factor`.
+            If True, the parameter `size` will be calculated using the value of the `scale_factor`,
+            and finally scaled using the value of `size`.
+            If False, the value of `size` or `scale_factor` will be used for direct interpolation. Default: None.
 
-                old_i = new_length != 0 ? new_i * old_length / new_length : 0  # if set to 'asymmetric'
+    Args Support List and Supported Platforms:
 
-        mode (str): The method used to interpolate: 'linear' | 'bilinear'. Default is 'linear'.
+    +----------------+------+----------------+---------------+------------------+
+    | mode           | dim  | align_corners  | scale_factor  | device           |
+    +================+======+================+===============+==================+
+    | nearest        | 3    | \-             | ×             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 4    | \-             | ×             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 5    | \-             | √             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | linear         | 3    | √              | ×             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | bilinear       | 4    | √              | ×             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    | trilinear      | 5    | √              | √             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | bicubic        | 4    | √              | ×             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | area           | 3    | \-             | √             | Ascend,GPU,CPU   |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 4    | \-             | √             | GPU              |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 5    | \-             | √             | GPU,CPU          |
+    +----------------+------+----------------+---------------+------------------+
+    | nearest-exact  | 3    | \-             | ×             | Ascend,CPU       |
+    +----------------+------+----------------+---------------+------------------+
+    |                | 4    | \-             | ×             | Ascend,CPU       |
+    +----------------+------+----------------+---------------+------------------+
 
-    Returns:
+    - `-` indicates that there is no such parameter.
-        Resized tensor, with the same data type as input `x`.
+    - `×` indicates that this parameter is not currently supported.
+    - `√` indicates that this parameter is supported.
+
+    Outputs:
+        Tensor, resized, whose dimensions and dtype are the same as `x`.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
+        TypeError: If `x` is not Tensor.
-        TypeError: If the data type of `x` is not supported.
+        TypeError: If `mode` is not one of 'nearest', 'linear', 'bilinear', 'bicubic',
-        TypeError: If `scales` is not a float tuple.
+            'trilinear', 'area', nor 'nearest-exact'.
-        ValueError: If not all numbers in `scales` are positive.
+        TypeError: If `size` is not one of tuple, list, None.
-        TypeError: If `sizes` is not an int tuple.
+        TypeError: If `scale_factor` is neither int nor None.
-        ValueError: If not all numbers in `sizes` are positive.
+        TypeError: If `align_corners` is not a bool.
-        TypeError: If `coordinate_transformation_mode` is not a string.
+        TypeError: If dtype of `x` is neither float16 nor float32.
-        ValueError: If `coordinate_transformation_mode` is not in the support list.
+        ValueError: If `size` and `scale_factor` are both None or not None.
-        TypeError: If `mode` is not a string.
+        ValueError: If shape of `x` or `size` and `mode` are not match.
-        ValueError: If `mode` is not in the support list.
+        ValueError: If `scale_factor` is an int which is less than 0.
-
+        ValueError: If `size` is a list or tuple whose length is not match `mode`.
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> # case 1: linear mode
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor([[[1, 2, 3], [4, 5, 6]]], mindspore.float32)
-        >>> output = ops.interpolate(x, None, None, (6,), "align_corners")
+        >>> output = ops.interpolate(x, size=(6,), mode='nearest')
         >>> print(output)
-        [[[1. 1.4 1.8 2.2 2.6 3.]
+            [[[1. 1. 2. 2. 3. 3.]
-          [4. 4.4 4.8 5.2 5.6 6.]]]
+              [4. 4. 5. 5. 6. 6.]]]
-        >>> # case 2: bilinear mode
-        >>> x = Tensor([[[[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]]]], mindspore.float32)
-        >>> output = ops.interpolate(x, None, None, (5, 5), "asymmetric", "bilinear")
-        >>> print(output)
-        [[[[1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]
-           [1. 2. 3. 4. 5.]]]]
     """
-    if not isinstance(x, (Tensor, Tensor_)):
-        raise TypeError("For interpolate, the input x must be tensor")
-    input_shape = x.shape
-    input_dims = len(input_shape)
-    _check_interpolate_inputs(input_dims, roi, scales, sizes, coordinate_transformation_mode, mode,
-                              "interpolate")
-    output_size = _interpolate_output_shape(input_shape, scales, sizes, mode)
 
-    if mode == "linear":
+    def run_nearest(x, size, align_corners=None, scale_factor=None):
-        resize_linear_inner = _get_cache_prim(IMG.ResizeLinear1D)(
+        # 3D 4D use ResizeNearestNeighborV2, 5D use UpsampleNearest3D
-            coordinate_transformation_mode=coordinate_transformation_mode)
+        if x.ndim == 3:
-        return resize_linear_inner(x, output_size)
+            size = Tensor((size[0], 1), dtype=mstype.int32)
-    if mode == "bilinear":
+            x = x.unsqueeze(-1)
+            x = _get_cache_prim(P.ResizeNearestNeighborV2)(data_format="NCHW")(x, size)
+            x = x.squeeze(-1)
+        elif x.ndim == 4:
+            size = Tensor(size, dtype=mstype.int32)
+            x = _get_cache_prim(P.ResizeNearestNeighborV2)(data_format="NCHW")(x, size)
+        else:
+            x = _get_cache_prim(P.UpsampleNearest3D)(size, scales=scale_factor)(x)
+        return x
+
+    def run_linear(x, size, align_corners=None, scale_factor=None):
+        coordinate_transformation_mode = "align_corners" if align_corners else "half_pixel"
+        resize = _get_cache_prim(P.image_ops.ResizeLinear1D)(
+            coordinate_transformation_mode
+        )
+        return resize(x, Tensor(size, dtype=mstype.int32))
+
+    def run_bilinear(x, size, align_corners=None, scale_factor=None):
+        resize = _get_cache_prim(P.ResizeBilinearV2)(align_corners, not align_corners)
+        return resize(x, size)
+
+    def run_trilinear(x, size, align_corners=None, scale_factor=None):
+        resize = _get_cache_prim(P.nn_ops.UpsampleTrilinear3D)(
+            output_size=size, scales=scale_factor, align_corners=align_corners
+        )
+        return resize(x)
+
+    def run_bicubic(x, size, align_corners=None, scale_factor=None):
+        resize = _get_cache_prim(P.image_ops.ResizeBicubic)(
+            align_corners=align_corners, half_pixel_centers=not align_corners
+        )
+        x = resize(x, Tensor(size, dtype=mstype.int32))
+        return x
+
+    def run_area(x, size, align_corners=None, scale_factor=None):
+        if x.ndim == 3:
+            resize = nn.AdaptiveAvgPool1d(output_size=size[0])
+            x = resize(x)
+        elif x.ndim == 4:
+            x = ops.adaptive_avg_pool2d(x, tuple(size))
+        else:
+            x = ops.adaptive_avg_pool3d(x, tuple(size))
+        return x
+
+    def run_nearest_exact(x, size, align_corners=None, scale_factor=None):
+        if x.ndim == 3:
+            size = Tensor((size[0], 1), dtype=mstype.int32)
+            # For impl of nearest 3D use 4D.
+            x = x.unsqueeze(-1)
+            resize = _get_cache_prim(P.ResizeNearestNeighborV2)(
+                data_format="NCHW", align_corners=False, half_pixel_centers=True
+            )
+            x = resize(x, size)
+            x = x.squeeze(-1)
+        if x.ndim == 4:
+            size = Tensor(size, dtype=mstype.int32)
+            resize = _get_cache_prim(P.ResizeNearestNeighborV2)(
+                data_format="NCHW", align_corners=False, half_pixel_centers=True
+            )
+            x = resize(x, size)
+        return x
+
+    # support_dict "mode":{dim:{"scale_factor", "align_corners"}}
+    supported_dict = {
+        "nearest": {3: (), 4: (), 5: ("scale_factor",)},
+        "linear": {3: ("align_corners",)},
+        "bilinear": {4: ("align_corners",)},
+        "bicubic": {4: ("align_corners",)},
+        "trilinear": {5: ("scale_factor", "align_corners")},
+        "area": {3: ("scale_factor",), 4: ("scale_factor",), 5: ("scale_factor",)},
+        "nearest-exact": {3: (), 4: ()},
+    }
+    resize_func = {
+        "nearest": run_nearest,
+        "linear": run_linear,
+        "bilinear": run_bilinear,
+        "bicubic": run_bicubic,
+        "trilinear": run_trilinear,
+        "area": run_area,
+        "nearest-exact": run_nearest_exact,
+    }
+    if not isinstance(x, Tensor):
+        raise TypeError(f"For 'interpolate', 'x' must be a tensor, but got {type(x)}")
+    if size is not None and scale_factor is not None:
+        raise ValueError(
+            "For 'interpolate', only one of size or scale_factor should be defined"
+        )
+    if size is not None:
+        if isinstance(size, (list, tuple)):
+            if len(size) != x.ndim - 2:
+                raise ValueError(
+                    f"For 'interpolate', 'x' and 'size' must have same number of spatial dimensions, "
+                    f"but got 'x' is {x.ndim - 2}D, 'size' is {len(size)}D"
+                )
+        else:
+            size = [size for _ in range(x.ndim - 2)]
+    elif scale_factor is not None:
+        if isinstance(scale_factor, (list, tuple)):
+            if len(scale_factor) != x.ndim - 2:
+                raise ValueError(
+                    f"For 'interpolate', 'x' and 'scale_factor' must have same number of spatial dimensions, "
+                    f"but got 'x' is {x.ndim - 2}D, 'scale_factor' is {len(size)}D"
+                )
+        else:
+            scale_factor = [scale_factor for _ in range(x.ndim - 2)]
+    else:
+        raise ValueError(
+            "For 'interpolate', either 'size' or 'scale_factor' should be defined"
+        )
+
+    if mode not in supported_dict:
+        raise ValueError(
+            f"For 'interpolate', 'mode' must be in '{list(supported_dict)}', but got {mode}"
+        )
+    if x.ndim not in supported_dict.get(mode):
+        raise ValueError(
+            f"For 'interpolate', {mode} only support '{list(supported_dict.get(mode, {}))}'D, but got {x.ndim}D"
+        )
+    # "area" mode always requires an explicit size rather than scale factor.
+    if mode == "area" and size is None:
+        recompute_scale_factor = True
+    if recompute_scale_factor is not None and recompute_scale_factor:
+        # todo: check bool type
+        if size is not None:
+            raise ValueError(
+                "For 'interpolate', 'recompute_scale_factor' is not meaningful with an explicit size"
+            )
+        size = _scale_factor_convert_size(x.shape, scale_factor, x.ndim - 2)
+        scale_factor = None
+    else:
+        if scale_factor is not None and "scale_factor" not in supported_dict.get(mode, {}).get(x.ndim):
+            raise ValueError(
+                f"For 'interpolate', 'scale_factor' option cannot currently be set with the "
+                f"mode = {mode} and dim = {x.ndim}D."
+            )
+    if align_corners is not None:
+        if "align_corners" not in supported_dict.get(mode, {}).get(x.ndim):
+            raise ValueError(
+                f"For 'interpolate', 'align_corners' option cannot currently be set with the "
+                f"mode = {mode}, and dim = {x.ndim}D"
+            )
+    else:
         align_corners = False
-        half_pixel_centers = False
+    return resize_func.get(mode)(x, size, align_corners, scale_factor)
-        if coordinate_transformation_mode == "align_corners":
-            align_corners = True
-        elif coordinate_transformation_mode == "half_pixel":
-            half_pixel_centers = True
-        resize_bilinear_inner = _get_cache_prim(IMG.ResizeBilinearV2)(align_corners, half_pixel_centers)
-        return resize_bilinear_inner(x, output_size)
-
-    raise TypeError(
-        "Input Error: For interpolate,  {} mode is not support now".format(mode))
 
 
 def softsign(x):

tests/st/ops/ascend/test_resize_bilinear.py

@@ -23,7 +23,7 @@ from mindspore import ParameterTuple
 
 class NetResizeBilinear(nn.Cell):
     def construct(self, inputs, size):
-        return ops.interpolate(inputs, None, None, size, "asymmetric", "bilinear")
+        return ops.ResizeBilinearV2(align_corners=False, half_pixel_centers=False)(inputs, size)
 
 
 def case():

tests/st/ops/cpu/test_resize_bilinear_grad_op.py

@@ -44,8 +44,8 @@ class ResizeBilinearGradAlignCornerF(nn.Cell):
 class NetResizeBilinearFunc(nn.Cell):
     def construct(self, inputs, size, align_corner=False, half_pixel_centers=False):
         if align_corner and not half_pixel_centers:
-            return ops.interpolate(inputs, None, None, size, "align_corners", "bilinear")
+            return ops.ResizeBilinearV2(align_corners=True, half_pixel_centers=False)(inputs, size)
-        return ops.interpolate(inputs, None, None, size, "half_pixel", "bilinear")
+        return ops.ResizeBilinearV2(align_corners=False, half_pixel_centers=True)(inputs, size)
 
 
 def test_resize_bilinear_grad_align_corner():

tests/st/ops/cpu/test_resize_bilinear_op.py

@@ -13,12 +13,10 @@
 # limitations under the License.
 # ============================================================================
 import numpy as np
-import pytest
 
 from mindspore import context, Tensor
 from mindspore.ops import operations as P
 from mindspore import nn
-import mindspore.ops as ops
 
 context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
 
@@ -547,167 +545,3 @@ def test_resize_nn_grayscale_align_corners_float(datatype=np.float32):
     diff = output.asnumpy() - expected_output.asnumpy()
     assert np.all(abs(diff) < error)
     assert np.all(abs(diff_align) < error)
-
-
-class NetResizeBilinearFunc(nn.Cell):
-    def construct(self, x, scale, size):
-        return ops.interpolate(x, None, scale, size, "asymmetric", "bilinear")
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-def test_resize_bilinar_func_cpu():
-    """
-    Feature: Test bilinear on cpu.
-    Description: bilinear executes by calling ResizeBilinearV2
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(np.float32))
-    resize_nn = NetResizeBilinearFunc()
-    output = resize_nn(input_tensor, None, (3, 7))
-    expect = np.array([[[[0.1, 0.15714286, 0.21428573, 0.27142859, 0.32857144,
-                          0.3857143, 0.4],
-                         [0.36666667, 0.42380953, 0.48095244, 0.53809524, 0.5952381,
-                          0.65238094, 0.6666667],
-                         [0.5, 0.55714285, 0.61428577, 0.67142856, 0.7285714,
-                          0.78571427, 0.8]]]]).astype(np.float32)
-    assert np.allclose(output.asnumpy(), expect)
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-def test_resize_bilinar_func_scale_cpu():
-    """
-    Feature: Test bilinear with scale on cpu.
-    Description: bilinear executes by calling ResizeBilinearV2
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(np.float32))
-    resize_nn = NetResizeBilinearFunc()
-    output = resize_nn(input_tensor, (1.0, 1.0, 4.0, 2.0), None)
-    expect = resize_nn(input_tensor, None, (8, 8))
-    assert np.allclose(output.asnumpy(), expect.asnumpy())
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-def test_resize_bilinar_func_cpu_fp16():
-    """
-    Feature: Test bilinear on cpu with fp16.
-    Description: bilinear executes by calling ResizeBilinearV2
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(np.float16))
-    resize_nn = NetResizeBilinearFunc()
-    output = resize_nn(input_tensor, None, (3, 7))
-    expect = np.array([[[[0.1, 0.15714286, 0.21428573, 0.27142859, 0.32857144,
-                          0.3857143, 0.4],
-                         [0.36666667, 0.42380953, 0.48095244, 0.53809524, 0.5952381,
-                          0.65238094, 0.6666667],
-                         [0.5, 0.55714285, 0.61428577, 0.67142856, 0.7285714,
-                          0.78571427, 0.8]]]]).astype(np.float16)
-    assert np.allclose(output.asnumpy(), expect)
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-def test_resize_bilinar_func_scale_cpu_fp16():
-    """
-    Feature: Test bilinear with scale on cpu with fp16.
-    Description: bilinear executes by calling ResizeBilinearV2
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(np.float16))
-    resize_nn = NetResizeBilinearFunc()
-    output = resize_nn(input_tensor, (1.0, 1.0, 4.0, 2.0), None)
-    expect = resize_nn(input_tensor, None, (8, 8))
-    assert np.allclose(output.asnumpy(), expect.asnumpy())
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-def test_resize_bilinar_func_cpu_fp64():
-    """
-    Feature: Test bilinear on cpu with fp64.
-    Description: bilinear executes by calling ResizeBilinearV2
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(np.float64))
-    resize_nn = NetResizeBilinearFunc()
-    output = resize_nn(input_tensor, None, (3, 7))
-    expect = np.array([[[[0.1, 0.15714286, 0.21428573, 0.27142859, 0.32857144,
-                          0.3857143, 0.4],
-                         [0.36666667, 0.42380953, 0.48095244, 0.53809524, 0.5952381,
-                          0.65238094, 0.6666667],
-                         [0.5, 0.55714285, 0.61428577, 0.67142856, 0.7285714,
-                          0.78571427, 0.8]]]]).astype(np.float64)
-    assert np.allclose(output.asnumpy(), expect)
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-def test_resize_bilinar_func_scale_cpu_fp64():
-    """
-    Feature: Test bilinear with scale on cpu with fp64.
-    Description: bilinear executes by calling ResizeBilinearV2
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(np.float64))
-    resize_nn = NetResizeBilinearFunc()
-    output = resize_nn(input_tensor, (1.0, 1.0, 4.0, 2.0), None)
-    expect = resize_nn(input_tensor, None, (8, 8))
-    assert np.allclose(output.asnumpy(), expect.asnumpy())
-
-
-@pytest.mark.level1
-@pytest.mark.platform_x86_cpu_training
-def test_resize_nn_func_half_pixel_centers(datatype=np.float32):
-    """
-    Feature: Test resize_bilinear on CPU.
-    Description:  The half_pixel_centers is True.
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(datatype))
-    resize_nn_func = NetResizeBilinearFunc()
-    output = resize_nn_func(input_tensor, (3, 7), align_corner=False, half_pixel_centers=True)
-    expected_output = np.array([[[[0.1, 0.13571429, 0.19285715, 0.25, 0.30714288,
-                                   0.36428574, 0.4],
-                                  [0.3, 0.3357143, 0.39285716, 0.45, 0.5071429,
-                                   0.56428576, 0.6],
-                                  [0.5, 0.5357143, 0.5928572, 0.65, 0.7071429,
-                                   0.76428574, 0.8]]]], dtype=datatype)
-    assert np.allclose(output.asnumpy(), expected_output)
-
-
-@pytest.mark.level1
-@pytest.mark.platform_x86_cpu_training
-def test_resize_nn_func_half_pixel_centers_fp16(datatype=np.float16):
-    """
-    Feature: Test resize_bilinear fp16 on CPU.
-    Description:  The half_pixel_centers is True.
-    Expectation: Assert that results are consistent with expect.
-    """
-    input_tensor = Tensor(
-        np.array([[[[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]]]]).astype(datatype))
-    resize_nn_func = NetResizeBilinearFunc()
-    output = resize_nn_func(input_tensor, (3, 7), align_corner=False, half_pixel_centers=True)
-    expected_output = np.array([[[[0.1, 0.13571429, 0.19285715, 0.25, 0.30714288,
-                                   0.36428574, 0.4],
-                                  [0.3, 0.3357143, 0.39285716, 0.45, 0.5071429,
-                                   0.56428576, 0.6],
-                                  [0.5, 0.5357143, 0.5928572, 0.65, 0.7071429,
-                                   0.76428574, 0.8]]]], dtype=datatype)
-    assert np.allclose(output.asnumpy(), expected_output)

tests/st/ops/cpu/test_resize_linear_1d_op.py

@@ -19,7 +19,6 @@ import pytest
 import mindspore.context as context
 from mindspore import Tensor
 from mindspore.ops.operations.image_ops import ResizeLinear1D
-from mindspore.ops import functional as F
 
 context.set_context(mode=context.GRAPH_MODE, device_target='CPU')
 
@@ -80,39 +79,3 @@ def test_resize_linear_1d_size_not_change(dtype):
     expect = np.array([[[1., 2., 3.],
                         [4., 5., 6.]]]).astype(dtype)
     assert np.allclose(output.asnumpy(), expect)
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-@pytest.mark.parametrize('dtype', [np.float32, np.float16])
-def test_resize_linear_1d_half_pixel_functional_interface(dtype):
-    """
-    Feature: ResizeLinear1D cpu kernel half_pixel mode functional interface.
-    Description: test the rightness of ResizeLinear1D cpu kernel.
-    Expectation: the output is same as expect.
-    """
-    x = Tensor(np.array([[[1, 2, 3],
-                          [4, 5, 6]]], dtype=dtype))
-    output = F.interpolate(x, None, None, (6,), 'half_pixel')
-    expect = np.array([[[1., 1.25, 1.75, 2.25, 2.75, 3.],
-                        [4., 4.25, 4.75, 5.25, 5.75, 6.]]]).astype(dtype)
-    assert np.allclose(output.asnumpy(), expect)
-
-
-@pytest.mark.level0
-@pytest.mark.platform_x86_cpu
-@pytest.mark.env_onecard
-@pytest.mark.parametrize('dtype', [np.float16, np.float64])
-def test_resize_linear_1d_align_corners_functional_interface(dtype):
-    """
-    Feature: ResizeLinear1D cpu kernel align_corners mode functional interface.
-    Description: test the rightness of ResizeLinear1D cpu kernel.
-    Expectation: the output is same as expect.
-    """
-    x = Tensor(np.array([[[1, 2, 3],
-                          [4, 5, 6]]], dtype=dtype))
-    output = F.interpolate(x, None, (1., 1., 2.), None, 'align_corners')
-    expect = np.array([[[1., 1.4, 1.8, 2.2, 2.6, 3.],
-                        [4., 4.4, 4.8, 5.2, 5.6, 6.]]]).astype(dtype)
-    assert np.allclose(output.asnumpy(), expect)

tests/st/ops/dynamic_shape/test_resize_bilinear_dyn.py

@@ -41,7 +41,7 @@ class NetResizeBilinear(nn.Cell):
     def construct(self, inputs, size, indices_input, axis):
         unique_input_index, _ = ops.unique(indices_input)
         inputs_dyn = ops.gather(inputs, unique_input_index, axis)
-        return ops.interpolate(inputs_dyn, None, None, size, "asymmetric", "bilinear")
+        return ops.ResizeBilinearV2(align_corners=False, half_pixel_centers=False)(inputs_dyn, size)
 
 
 def case_input_dyn(mode, device_target, dtype="float32"):

tests/st/ops/gpu/test_resize_bilinear_op.py

@@ -576,8 +576,8 @@ def test_resize_nn_grayscale_align_corners_float(datatype=np.float32):
 class NetResizeBilinearFunc(nn.Cell):
     def construct(self, inputs, size, align_corner=False, half_pixel_centers=False):
         if align_corner and not half_pixel_centers:
-            return ops.interpolate(inputs, None, None, size, "align_corners", "bilinear")
+            return ops.ResizeBilinearV2(align_corners=True, half_pixel_centers=False)(inputs, size)
-        return ops.interpolate(inputs, None, None, size, "half_pixel", "bilinear")
+        return ops.ResizeBilinearV2(align_corners=False, half_pixel_centers=True)(inputs, size)
 
 
 @pytest.mark.level1

tests/st/ops/gpu/test_resize_linear_1d_op.py

@@ -19,7 +19,6 @@ import pytest
 import mindspore.context as context
 from mindspore import Tensor
 from mindspore.ops.operations.image_ops import ResizeLinear1D
-from mindspore.ops import functional as F
 
 context.set_context(mode=context.GRAPH_MODE, device_target='GPU')
 
@@ -80,39 +79,3 @@ def test_resize_linear_1d_size_not_change(dtype):
     expect = np.array([[[1., 2., 3.],
                         [4., 5., 6.]]]).astype(dtype)
     assert np.allclose(output.asnumpy(), expect)
-
-
-@pytest.mark.level1
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.env_onecard
-@pytest.mark.parametrize('dtype', [np.float32, np.float16])
-def test_resize_linear_1d_half_pixel_functional_interface(dtype):
-    """
-    Feature: ResizeLinear1D gpu kernel half_pixel mode functional interface.
-    Description: test the rightness of ResizeLinear1D cpu kernel.
-    Expectation: the output is same as expect.
-    """
-    x = Tensor(np.array([[[1, 2, 3],
-                          [4, 5, 6]]], dtype=dtype))
-    output = F.interpolate(x, None, None, (6,), 'half_pixel')
-    expect = np.array([[[1., 1.25, 1.75, 2.25, 2.75, 3.],
-                        [4., 4.25, 4.75, 5.25, 5.75, 6.]]]).astype(dtype)
-    assert np.allclose(output.asnumpy(), expect)
-
-
-@pytest.mark.level1
-@pytest.mark.platform_x86_gpu_training
-@pytest.mark.env_onecard
-@pytest.mark.parametrize('dtype', [np.float16, np.float64])
-def test_resize_linear_1d_align_corners_functional_interface(dtype):
-    """
-    Feature: ResizeLinear1D gpu kernel align_corners mode functional interface.
-    Description: test the rightness of ResizeLinear1D cpu kernel.
-    Expectation: the output is same as expect.
-    """
-    x = Tensor(np.array([[[1, 2, 3],
-                          [4, 5, 6]]], dtype=dtype))
-    output = F.interpolate(x, None, (1., 1., 2.), None, 'align_corners')
-    expect = np.array([[[1., 1.4, 1.8, 2.2, 2.6, 3.],
-                        [4., 4.4, 4.8, 5.2, 5.6, 6.]]]).astype(dtype)
-    assert np.allclose(output.asnumpy(), expect)

tests/st/ops/test_interpolate.py

@@ -0,0 +1,754 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+import numpy as np
+import pytest
+import mindspore as ms
+import mindspore.nn as nn
+from mindspore import Tensor
+from mindspore import ops
+
+
+class Net(nn.Cell):
+    def __init__(self, mode):
+        super(Net, self).__init__()
+        self.mode = mode
+
+    def construct(self, x, size=None, scale_factor=None, align_corners=None, recompute_scale_factor=None):
+        return ops.interpolate(x, size, scale_factor, self.mode, align_corners, recompute_scale_factor)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_area_3d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate area mode
+                1. 3D size
+                2. 3D scale_factor
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("area")
+
+    # 1. 3D(1, 3, 5)
+    input_3d = np.array([[[0.816117, 0.004037, 0.746452, 0.137449, 0.337593],
+                          [0.970709, 0.558792, 0.053919, 0.734102, 0.432973],
+                          [0.830186, 0.77753, 0.384094, 0.905231, 0.76362]]], dtype=np.float32)
+    except_3d_1 = np.array([[[0.410077, 0.375244, 0.441951, 0.237521],
+                             [0.76475, 0.306356, 0.394011, 0.583538],
+                             [0.803858, 0.580812, 0.644662, 0.834426]]], dtype=np.float32)
+    size = 4
+    output_3d_1 = net(Tensor(input_3d), size=size)
+    assert np.allclose(output_3d_1.asnumpy(), except_3d_1, atol=1e-3, rtol=1e-3)
+
+    # 2. 3D(1, 3, 5) scale_factor=0.2
+    except_3d_2 = np.array([[[0.40833],
+                             [0.550099],
+                             [0.732132]]], dtype=np.float32)
+    scale_factor = 0.2
+    output_3d_2 = net(Tensor(input_3d), scale_factor=scale_factor)
+    assert np.allclose(output_3d_2.asnumpy(), except_3d_2, atol=1e-3, rtol=1e-3)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_area_4d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate area mode
+                1. 4D size
+                2. 4D scale_factor
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("area")
+
+    # 1. 4D(1, 3, 3, 5) size=(5, 8)
+    input_4d = np.array([[[[0.4992, 0.743079, 0.570383, 0.942855, 0.833395],
+                           [0.645754, 0.485126, 0.957497, 0.933144, 0.556276],
+                           [0.298626, 0.594928, 0.150964, 0.447654, 0.267512],
+                           [0.46943, 0.419558, 0.665492, 0.414906, 0.708427]]]], dtype=np.float32)
+    except_4d_1 = np.array([[[[0.4992, 0.62114, 0.743079, 0.656731, 0.756619, 0.942855,
+                               0.888125, 0.833395],
+                              [0.572477, 0.59329, 0.614102, 0.689021, 0.85097, 0.937999,
+                               0.816418, 0.694836],
+                              [0.47219, 0.506109, 0.540027, 0.547129, 0.622315, 0.690399,
+                               0.551147, 0.411894],
+                              [0.384028, 0.445635, 0.507243, 0.457736, 0.419754, 0.43128,
+                               0.459625, 0.48797],
+                              [0.46943, 0.444494, 0.419558, 0.542525, 0.540199, 0.414906,
+                               0.561666, 0.708427]]]], dtype=np.float32)
+    size = (5, 8)
+    output_4d_1 = net(Tensor(input_4d), size=size)
+    assert np.allclose(output_4d_1.asnumpy(), except_4d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 4D(1, 3, 3, 5) scale_factor=(1.5, 0.4)
+    except_4d_2 = np.array([[[[0.604221, 0.782211],
+                              [0.650173, 0.798925],
+                              [0.696126, 0.815639],
+                              [0.348173, 0.28871],
+                              [0.433166, 0.442492],
+                              [0.51816, 0.596275]]]], dtype=np.float32)
+    scale_factor = (1.5, 0.4)
+    output_4d_2 = net(Tensor(input_4d), scale_factor=scale_factor)
+    assert np.allclose(output_4d_2.asnumpy(), except_4d_2, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_area_5d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate area mode
+                1. 5D size
+                2. 5D scale_factor
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("area")
+
+    # 1. 5D(1, 1, 1, 4, 5) size=(2, 4, 3)
+    input_5d = np.array([[[[[0.4992, 0.743079, 0.570383, 0.942855, 0.833395],
+                            [0.645754, 0.485126, 0.957497, 0.933144, 0.556276],
+                            [0.298626, 0.594928, 0.150964, 0.447654, 0.267512],
+                            [0.46943, 0.419558, 0.665492, 0.414906, 0.708427]]]]], dtype=np.float32)
+    except_5d_1 = np.array([[[[[0.62114, 0.752106, 0.888125],
+                               [0.56544, 0.791922, 0.74471],
+                               [0.446777, 0.397849, 0.357583],
+                               [0.444494, 0.499985, 0.561666]],
+
+                              [[0.62114, 0.752106, 0.888125],
+                               [0.56544, 0.791922, 0.74471],
+                               [0.446777, 0.397849, 0.357583],
+                               [0.444494, 0.499985, 0.561666]]]]], dtype=np.float32)
+    size = (2, 4, 3)
+    output_5d_1 = net(Tensor(input_5d), size=size)
+    assert np.allclose(output_5d_1.asnumpy(),
+                       except_5d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 5D(1, 1, 1, 4, 5) scale_factor=(3, 0.4, 0.7)
+    except_5d_2 = np.array([[[[[0.519463, 0.610466, 0.638021]],
+                              [[0.519463, 0.610466, 0.638021]],
+                              [[0.519463, 0.610466, 0.638021]]]]], dtype=np.float32)
+    scale_factor = (3., 0.4, 0.7)
+    output_5d_2 = net(Tensor(input_5d), scale_factor=scale_factor)
+    assert np.allclose(output_5d_2.asnumpy(), except_5d_2, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_bicubic(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate bicubic mode
+                1. 4D size tf
+                2. 4D size align_corners=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("bicubic")
+    input_4d = np.array([[[[0.003088, 0.313131, 0.481231, 0.326219, 0.190293],
+                           [0.711616, 0.583990, 0.718121, 0.258823, 0.121847],
+                           [0.781316, 0.591508, 0.858185, 0.091935, 0.444639]],
+                          [[0.389884, 0.894497, 0.471427, 0.188708, 0.557449],
+                           [0.998047, 0.380719, 0.570574, 0.722258, 0.997173],
+                           [0.195751, 0.050744, 0.002008, 0.482685, 0.708559]]]],
+                        dtype=np.float32)
+    size = (5, 3)
+    # 1. 4D size=(5, 3)
+    except_4d_1 = np.array([[[[0.038226, 0.46334, 0.228343],
+                              [0.287464, 0.558147, 0.186838],
+                              [0.671836, 0.718121, 0.14377],
+                              [0.729394, 0.819616, 0.255285],
+                              [0.723466, 0.868763, 0.334474]],
+
+                             [[0.522484, 0.463939, 0.409831],
+                              [0.670862, 0.531739, 0.626711],
+                              [0.821431, 0.570574, 0.926654],
+                              [0.40312, 0.206133, 0.777062],
+                              [0.107333, -0.040933, 0.642958]]]], dtype=np.float32)
+    output_4d_1 = net(Tensor(input_4d), size=size)
+    assert np.allclose(output_4d_1.asnumpy(),
+                       except_4d_1, atol=1e-5, rtol=1e-5)
+    # 2. 4D size=(5, 3), align_corners=True
+    except_4d_2 = np.array([[[[0.003088, 0.481231, 0.190293],
+                              [0.350818, 0.586545, 0.125808],
+                              [0.711616, 0.718121, 0.121847],
+                              [0.81289, 0.810361, 0.276826],
+                              [0.781316, 0.858185, 0.444639]],
+
+                             [[0.389884, 0.471427, 0.557449],
+                              [0.769181, 0.574304, 0.804369],
+                              [0.998047, 0.570574, 0.997173],
+                              [0.653914, 0.295586, 0.89409],
+                              [0.195751, 0.002008, 0.708559]]]], dtype=np.float32)
+    output_4d_2 = net(Tensor(input_4d), size=size, align_corners=True)
+
+    assert np.allclose(output_4d_2.asnumpy(), except_4d_2, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_linear(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate linear mode
+                1. 3D size
+                2. 3D size align_corners=True
+                3. 3D scale_factor recompute_scale_factor=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("linear")
+
+    # 1. 3D(1, 3, 5) size=8
+    input_3d = np.array([[[0.784811, 0.008794, 0.52707, 0.821989, 0.88349],
+                          [0.00115, 0.556748, 0.8774, 0.761826, 0.23384],
+                          [0.842441, 0.853507, 0.294813, 0.375813, 0.399932]]], dtype=np.float32)
+    except_3d_1 = np.array([[[0.784811, 0.445304, 0.041186, 0.365109, 0.619232, 0.803557, 0.856583, 0.88349],
+                             [0.00115, 0.244224, 0.576789, 0.777196, 0.841283, 0.769049, 0.464834, 0.23384],
+                             [0.842441, 0.847282, 0.818589, 0.469405, 0.320126, 0.370751, 0.38938, 0.399932]]],
+                           dtype=np.float32)
+    size = 8
+    output_3d_1 = net(Tensor(input_3d), size=size)
+    assert np.allclose(output_3d_1.asnumpy(), except_3d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 3D(1, 3, 5) size=8 align_corners=True
+    except_3d_2 = np.array([[[0.784811, 0.341373, 0.082833, 0.378991, 0.611333, 0.779858,
+                              0.848347, 0.88349],
+                             [0.00115, 0.318635, 0.602555, 0.785785, 0.844379, 0.778337,
+                              0.535546, 0.23384],
+                             [0.842441, 0.848764, 0.773694, 0.45444, 0.317956, 0.364242,
+                              0.38615, 0.399932]]], dtype=np.float32)
+    output_3d_2 = net(Tensor(input_3d), size=size, align_corners=True)
+    assert np.allclose(output_3d_2.asnumpy(), except_3d_2, atol=1e-5, rtol=1e-5)
+
+    # 3. scale_factor=0.7, recompute_scale_factor=True
+    except_3d_3 = np.array([[[0.526139, 0.52707, 0.86299],
+                             [0.186349, 0.8774, 0.409835],
+                             [0.84613, 0.294813, 0.391892]]], dtype=np.float32)
+    scale_factor = 0.7
+    output_3d_3 = net(Tensor(input_3d), scale_factor=scale_factor, recompute_scale_factor=True)
+    assert np.allclose(output_3d_3.asnumpy(), except_3d_3, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_bilinear(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate bilinear mode
+                1. 4D size
+                2. 4D size align_corners=True
+                3. 4D scale_factor recompute_scale_factor=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("bilinear")
+    input_4d = np.array([[[[0.003088, 0.313131, 0.481231, 0.326219, 0.190293],
+                           [0.711616, 0.58399, 0.718121, 0.258823, 0.121847],
+                           [0.781316, 0.591508, 0.858185, 0.091935, 0.444639]],
+                          [[0.389884, 0.894497, 0.471427, 0.188708, 0.557449],
+                           [0.998047, 0.380719, 0.570574, 0.722258, 0.997173],
+                           [0.195751, 0.050744, 0.002008, 0.482685, 0.708559]]]],
+                        dtype=np.float32)
+    size = (5, 3)
+
+    # 1. 4D size=(5, 3)
+    except_4d_1 = np.array([[[[0.106436, 0.481231, 0.235602],
+                              [0.331491, 0.575987, 0.208363],
+                              [0.669074, 0.718121, 0.167506],
+                              [0.698458, 0.802159, 0.263245],
+                              [0.718047, 0.858185, 0.327071]],
+                             [[0.558088, 0.471427, 0.434535],
+                              [0.651761, 0.511086, 0.622935],
+                              [0.792271, 0.570574, 0.905535],
+                              [0.405358, 0.229434, 0.742174],
+                              [0.147415, 0.002008, 0.633268]]]], dtype=np.float32)
+    output_4d_1 = net(Tensor(input_4d), size=size)
+    assert np.allclose(output_4d_1.asnumpy(), except_4d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 4D size=(5, 3), align_corners=True
+    except_4d_2 = np.array([[[[0.003088, 0.481231, 0.190293],
+                              [0.357352, 0.599676, 0.15607],
+                              [0.711616, 0.718121, 0.121847],
+                              [0.746466, 0.788153, 0.283243],
+                              [0.781316, 0.858185, 0.444639]],
+
+                             [[0.389884, 0.471427, 0.557449],
+                              [0.693965, 0.521001, 0.777311],
+                              [0.998047, 0.570574, 0.997173],
+                              [0.596899, 0.286291, 0.852866],
+                              [0.195751, 0.002008, 0.708559]]]], dtype=np.float32)
+    output_4d_2 = net(Tensor(input_4d), size=size, align_corners=True)
+    assert np.allclose(output_4d_2.asnumpy(), except_4d_2, atol=1e-5, rtol=1e-5)
+
+    # 3. scale_factor=(0.5, 1.5), recompute_scale_factor=True
+    scale_factor = (0.5, 1.5)
+    except_4d_3 = np.array([[[[0.711616, 0.638687, 0.622313, 0.718121, 0.390051, 0.200119,
+                               0.121847]],
+
+                             [[0.998047, 0.645288, 0.434963, 0.570574, 0.67892, 0.840079,
+                               0.997173]]]], dtype=np.float32)
+    output_4d_3 = net(Tensor(input_4d), scale_factor=scale_factor, recompute_scale_factor=True)
+    assert np.allclose(output_4d_3.asnumpy(), except_4d_3, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_trilinear(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate trilinear mode
+                1. 5D size
+                2. 5D size align_corners=True
+                3. 5D scale_factor
+                4. 5D scale_factor align_corners=True
+                5. 5D scale_factor align_corners=True recompute_scale_factor=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("trilinear")
+    # 1. 5D size (1, 1, 2, 3, 4)
+    input_5d = np.array([[[[[0.415192, 0.34623, 0.339439, 0.509735],
+                            [0.004669, 0.383352, 0.951564, 0.405198],
+                            [0.038453, 0.526071, 0.010246, 0.164402]],
+
+                           [[0.530777, 0.452261, 0.012696, 0.99017],
+                            [0.899132, 0.921811, 0.812974, 0.254313],
+                            [0.713248, 0.420471, 0.757313, 0.815576]]]]], dtype=np.float32)
+    size = (3, 4, 5)
+    except_5d_1 = np.array([[[[[0.415192, 0.366919, 0.342835, 0.390528, 0.509735],
+                               [0.158615, 0.306186, 0.545724, 0.638732, 0.444399],
+                               [0.017338, 0.311012, 0.517721, 0.513469, 0.3149],
+                               [0.038453, 0.379786, 0.268158, 0.056493, 0.164402]],
+
+                              [[0.472984, 0.421367, 0.287657, 0.348233, 0.749952],
+                               [0.459807, 0.528248, 0.587512, 0.578409, 0.487329],
+                               [0.423382, 0.536753, 0.640338, 0.603688, 0.389843],
+                               [0.37585, 0.444045, 0.428525, 0.415642, 0.489989]],
+
+                              [[0.530777, 0.475816, 0.232478, 0.305938, 0.99017],
+                               [0.760999, 0.75031, 0.6293, 0.518087, 0.530259],
+                               [0.829425, 0.762494, 0.762955, 0.693907, 0.464787],
+                               [0.713248, 0.508304, 0.588892, 0.774792, 0.815576]]]]], dtype=np.float32)
+    output_5d_1 = net(Tensor(input_5d), size=size)
+    assert np.allclose(output_5d_1.asnumpy(), except_5d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 5D size align_corners=True
+    except_5d_2 = np.array([[[[[0.415192, 0.36347, 0.342835, 0.382013, 0.509735],
+                               [0.14151, 0.313611, 0.55925, 0.670653, 0.440044],
+                               [0.01593, 0.327176, 0.534358, 0.559577, 0.324933],
+                               [0.038453, 0.404166, 0.268158, 0.048785, 0.164402]],
+
+                              [[0.472984, 0.41768, 0.287657, 0.319539, 0.749952],
+                               [0.458928, 0.540834, 0.607502, 0.602607, 0.469821],
+                               [0.426551, 0.551246, 0.654459, 0.632871, 0.383167],
+                               [0.37585, 0.448916, 0.428525, 0.410332, 0.489989]],
+
+                              [[0.530777, 0.47189, 0.232478, 0.257064, 0.99017],
+                               [0.776347, 0.768057, 0.655755, 0.534561, 0.499599],
+                               [0.837171, 0.775316, 0.774559, 0.706165, 0.441401],
+                               [0.713248, 0.493665, 0.588892, 0.771879, 0.815576]]]]],
+                           dtype=np.float32)
+    output_5d_2 = net(Tensor(input_5d), size=size, align_corners=True)
+    assert np.allclose(output_5d_2.asnumpy(), except_5d_2, atol=1e-5, rtol=1e-5)
+
+    # 3. 5D size scale_factor
+    scale_factor = (1.5, 1.2, 0.5)
+    except_5d_3 = np.array([[[[[0.380711, 0.424587],
+                               [0.194011, 0.678381],
+                               [0.282262, 0.087324]],
+
+                              [[0.436115, 0.46301],
+                               [0.552241, 0.606012],
+                               [0.424561, 0.436884]],
+
+                              [[0.491519, 0.501433],
+                               [0.910471, 0.533643],
+                               [0.566859, 0.786444]]]]], dtype=np.float32)
+    output_5d_3 = net(Tensor(input_5d), scale_factor=scale_factor)
+    assert np.allclose(output_5d_3.asnumpy(), except_5d_3, atol=1e-5, rtol=1e-5)
+
+    # 4. 5D size scale_factor align_corners=True
+    except_5d_4 = np.array([[[[[0.415192, 0.509735],
+                               [0.004669, 0.405198],
+                               [0.038453, 0.164402]],
+
+                              [[0.472984, 0.749952],
+                               [0.451901, 0.329755],
+                               [0.37585, 0.489989]],
+
+                              [[0.530777, 0.99017],
+                               [0.899132, 0.254313],
+                               [0.713248, 0.815576]]]]], dtype=np.float32)
+    output_5d_4 = net(Tensor(input_5d), scale_factor=scale_factor, align_corners=True)
+    assert np.allclose(output_5d_4.asnumpy(), except_5d_4, atol=1e-5, rtol=1e-5)
+
+    # 5. 5D size scale_factor align_corners=True recompute_scale_factor=True
+    except_5d_5 = np.array([[[[[0.415192, 0.509735],
+                               [0.004669, 0.405198],
+                               [0.038453, 0.164402]],
+
+                              [[0.472984, 0.749952],
+                               [0.451901, 0.329755],
+                               [0.37585, 0.489989]],
+
+                              [[0.530777, 0.99017],
+                               [0.899132, 0.254313],
+                               [0.713248, 0.815576]]]]], dtype=np.float32)
+    output_5d_5 = net(Tensor(input_5d), scale_factor=scale_factor, align_corners=True, recompute_scale_factor=True)
+    assert np.allclose(output_5d_5.asnumpy(), except_5d_5, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_trilinear_gpu(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate trilinear mode
+                1. 5D size
+                2. 5D size align_corners=True
+                3. 5D scale_factor failed I6D8EN
+                4. 5D scale_factor align_corners=True failed I6D8EN
+                5. 5D scale_factor align_corners=True recompute_scale_factor=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("trilinear")
+    # 1. 5D size (1, 1, 2, 3, 4)
+    input_5d = np.array([[[[[0.415192, 0.34623, 0.339439, 0.509735],
+                            [0.004669, 0.383352, 0.951564, 0.405198],
+                            [0.038453, 0.526071, 0.010246, 0.164402]],
+
+                           [[0.530777, 0.452261, 0.012696, 0.99017],
+                            [0.899132, 0.921811, 0.812974, 0.254313],
+                            [0.713248, 0.420471, 0.757313, 0.815576]]]]], dtype=np.float32)
+    size = (3, 4, 5)
+    except_5d_1 = np.array([[[[[0.415192, 0.366919, 0.342835, 0.390528, 0.509735],
+                               [0.158615, 0.306186, 0.545724, 0.638732, 0.444399],
+                               [0.017338, 0.311012, 0.517721, 0.513469, 0.3149],
+                               [0.038453, 0.379786, 0.268158, 0.056493, 0.164402]],
+
+                              [[0.472984, 0.421367, 0.287657, 0.348233, 0.749952],
+                               [0.459807, 0.528248, 0.587512, 0.578409, 0.487329],
+                               [0.423382, 0.536753, 0.640338, 0.603688, 0.389843],
+                               [0.37585, 0.444045, 0.428525, 0.415642, 0.489989]],
+
+                              [[0.530777, 0.475816, 0.232478, 0.305938, 0.99017],
+                               [0.760999, 0.75031, 0.6293, 0.518087, 0.530259],
+                               [0.829425, 0.762494, 0.762955, 0.693907, 0.464787],
+                               [0.713248, 0.508304, 0.588892, 0.774792, 0.815576]]]]], dtype=np.float32)
+    output_5d_1 = net(Tensor(input_5d), size=size)
+    assert np.allclose(output_5d_1.asnumpy(), except_5d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 5D size align_corners=True
+    except_5d_2 = np.array([[[[[0.415192, 0.36347, 0.342835, 0.382013, 0.509735],
+                               [0.14151, 0.313611, 0.55925, 0.670653, 0.440044],
+                               [0.01593, 0.327176, 0.534358, 0.559577, 0.324933],
+                               [0.038453, 0.404166, 0.268158, 0.048785, 0.164402]],
+
+                              [[0.472984, 0.41768, 0.287657, 0.319539, 0.749952],
+                               [0.458928, 0.540834, 0.607502, 0.602607, 0.469821],
+                               [0.426551, 0.551246, 0.654459, 0.632871, 0.383167],
+                               [0.37585, 0.448916, 0.428525, 0.410332, 0.489989]],
+
+                              [[0.530777, 0.47189, 0.232478, 0.257064, 0.99017],
+                               [0.776347, 0.768057, 0.655755, 0.534561, 0.499599],
+                               [0.837171, 0.775316, 0.774559, 0.706165, 0.441401],
+                               [0.713248, 0.493665, 0.588892, 0.771879, 0.815576]]]]],
+                           dtype=np.float32)
+    output_5d_2 = net(Tensor(input_5d), size=size, align_corners=True)
+    assert np.allclose(output_5d_2.asnumpy(), except_5d_2, atol=1e-5, rtol=1e-5)
+
+    scale_factor = (1.5, 1.2, 0.5)
+    # 5. 5D size scale_factor align_corners=True recompute_scale_factor=True
+    except_5d_5 = np.array([[[[[0.415192, 0.509735],
+                               [0.004669, 0.405198],
+                               [0.038453, 0.164402]],
+
+                              [[0.472984, 0.749952],
+                               [0.451901, 0.329755],
+                               [0.37585, 0.489989]],
+
+                              [[0.530777, 0.99017],
+                               [0.899132, 0.254313],
+                               [0.713248, 0.815576]]]]], dtype=np.float32)
+    output_5d_5 = net(Tensor(input_5d), scale_factor=scale_factor, align_corners=True, recompute_scale_factor=True)
+    assert np.allclose(output_5d_5.asnumpy(), except_5d_5, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_nearest_exact_3d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate nearest-exact mode
+                1. 3D size
+                2. 3D scale_factor recompute_scale_factor=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("nearest-exact")
+
+    # 1. 3D(1, 3, 5) size=8
+    input_3d = np.array([[[0.816117, 0.004037, 0.746452, 0.137449, 0.337593],
+                          [0.970709, 0.558792, 0.053919, 0.734102, 0.432973],
+                          [0.830186, 0.77753, 0.384094, 0.905231, 0.76362]]], dtype=np.float32)
+    except_3d_1 = np.array([[[0.816117, 0.816117, 0.004037, 0.746452, 0.746452, 0.137449,
+                              0.337593, 0.337593],
+                             [0.970709, 0.970709, 0.558792, 0.053919, 0.053919, 0.734102,
+                              0.432973, 0.432973],
+                             [0.830186, 0.830186, 0.77753, 0.384094, 0.384094, 0.905231,
+                              0.76362, 0.76362]]], dtype=np.float32)
+    size = 8
+    output_3d_1 = net(Tensor(input_3d), size=size)
+    assert np.allclose(output_3d_1.asnumpy(), except_3d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 3D(1, 3, 5) scale_factor=0.7 recompute_scale_factor=True
+    except_3d_2 = np.array([[[0.816117, 0.746452, 0.337593],
+                             [0.970709, 0.053919, 0.432973],
+                             [0.830186, 0.384094, 0.76362]]], dtype=np.float32)
+    scale_factor = 0.7
+    output_3d_2 = net(Tensor(input_3d), scale_factor=scale_factor, recompute_scale_factor=True)
+    assert np.allclose(output_3d_2.asnumpy(), except_3d_2, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_nearest_exact_4d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate nearest-exact mode
+    Expectation: success
+    1. 4D size
+    2. 4D scale_factor recompute_scale_factor=True
+    """
+    ms.set_context(mode=mode)
+    net = Net("nearest-exact")
+
+    # 1. 4D(1, 3, 3, 5) size=(5, 8)
+    size = (5, 8)
+    input_4d = np.array([[[[0.4992, 0.743079, 0.570383, 0.942855, 0.833395],
+                           [0.645754, 0.485126, 0.957497, 0.933144, 0.556276],
+                           [0.298626, 0.594928, 0.150964, 0.447654, 0.267512],
+                           [0.46943, 0.419558, 0.665492, 0.414906, 0.708427]]]], dtype=np.float32)
+    except_4d_1 = np.array([[[[0.4992, 0.4992, 0.743079, 0.570383, 0.570383, 0.942855,
+                               0.833395, 0.833395],
+                              [0.645754, 0.645754, 0.485126, 0.957497, 0.957497, 0.933144,
+                               0.556276, 0.556276],
+                              [0.298626, 0.298626, 0.594928, 0.150964, 0.150964, 0.447654,
+                               0.267512, 0.267512],
+                              [0.298626, 0.298626, 0.594928, 0.150964, 0.150964, 0.447654,
+                               0.267512, 0.267512],
+                              [0.46943, 0.46943, 0.419558, 0.665492, 0.665492, 0.414906,
+                               0.708427, 0.708427]]]], dtype=np.float32)
+    output_4d_1 = net(Tensor(input_4d), size=size)
+    assert np.allclose(output_4d_1.asnumpy(), except_4d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 4D(1, 3, 3, 5) scale_factor=(1.5, 0.4) recompute_scale_factor=True
+    scale_factor = (1.5, 0.4)
+    except_4d_2 = np.array([[[[0.743079, 0.942855],
+                              [0.485126, 0.933144],
+                              [0.485126, 0.933144],
+                              [0.594928, 0.447654],
+                              [0.419558, 0.414906],
+                              [0.419558, 0.414906]]]], dtype=np.float32)
+    output_4d_2 = net(Tensor(input_4d), scale_factor=scale_factor, recompute_scale_factor=True)
+    assert np.allclose(output_4d_2.asnumpy(), except_4d_2, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_nearest_3d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate nearest mode
+                1. 3D size
+                2. 3D scale_factor recompute_scale_factor=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("nearest")
+
+    # 1. 3D(1, 3, 5) size=8
+    size = 8
+    input_3d = np.array([[[0.816117, 0.004037, 0.746452, 0.137449, 0.337593],
+                          [0.970709, 0.558792, 0.053919, 0.734102, 0.432973],
+                          [0.830186, 0.77753, 0.384094, 0.905231, 0.76362]]], dtype=np.float32)
+    except_3d_1 = np.array([[[0.816117, 0.816117, 0.004037, 0.004037, 0.746452, 0.137449,
+                              0.137449, 0.337593],
+                             [0.970709, 0.970709, 0.558792, 0.558792, 0.053919, 0.734102,
+                              0.734102, 0.432973],
+                             [0.830186, 0.830186, 0.77753, 0.77753, 0.384094, 0.905231,
+                              0.905231, 0.76362]]], dtype=np.float32)
+    output_3d_1 = net(Tensor(input_3d), size=size)
+    assert np.allclose(output_3d_1.asnumpy(), except_3d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 3D(1, 3, 5) scale_factor=0.7 recompute_scale_factor=True
+    except_3d_2 = np.array([[[0.816117, 0.004037, 0.137449],
+                             [0.970709, 0.558792, 0.734102],
+                             [0.830186, 0.77753, 0.905231]]], dtype=np.float32)
+    scale_factor = 0.7
+    output_3d_2 = net(Tensor(input_3d), scale_factor=scale_factor, recompute_scale_factor=True)
+    assert np.allclose(output_3d_2.asnumpy(), except_3d_2, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.platform_arm_ascend_training
+@pytest.mark.platform_x86_ascend_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_nearest_4d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate nearest mode
+                1. 4D size
+                2. 4D scale_factor recompute_scale_factor=True
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("nearest")
+
+    # 1. 4D(1, 3, 3, 5) size=(5, 8)
+    size = (5, 8)
+    input_4d = np.array([[[[0.4992, 0.743079, 0.570383, 0.942855, 0.833395],
+                           [0.645754, 0.485126, 0.957497, 0.933144, 0.556276],
+                           [0.298626, 0.594928, 0.150964, 0.447654, 0.267512],
+                           [0.46943, 0.419558, 0.665492, 0.414906, 0.708427]]]], dtype=np.float32)
+    except_4d_1 = np.array([[[[0.4992, 0.4992, 0.743079, 0.743079, 0.570383, 0.942855,
+                               0.942855, 0.833395],
+                              [0.4992, 0.4992, 0.743079, 0.743079, 0.570383, 0.942855,
+                               0.942855, 0.833395],
+                              [0.645754, 0.645754, 0.485126, 0.485126, 0.957497, 0.933144,
+                               0.933144, 0.556276],
+                              [0.298626, 0.298626, 0.594928, 0.594928, 0.150964, 0.447654,
+                               0.447654, 0.267512],
+                              [0.46943, 0.46943, 0.419558, 0.419558, 0.665492, 0.414906,
+                               0.414906, 0.708427]]]], dtype=np.float32)
+    output_4d_1 = net(Tensor(input_4d), size=size)
+    assert np.allclose(output_4d_1.asnumpy(), except_4d_1, atol=1e-5, rtol=1e-5)
+
+    # 2. 4D(1, 3, 3, 5) scale_factor=(1.5, 0.4) recompute_scale_factor=True
+    except_4d_2 = np.array([[[[0.4992, 0.570383],
+                              [0.4992, 0.570383],
+                              [0.645754, 0.957497],
+                              [0.298626, 0.150964],
+                              [0.298626, 0.150964],
+                              [0.46943, 0.665492]]]], dtype=np.float32)
+    scale_factor = (1.5, 0.4)
+    output_4d_2 = net(Tensor(input_4d), scale_factor=scale_factor, recompute_scale_factor=True)
+    assert np.allclose(output_4d_2.asnumpy(), except_4d_2, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.level0
+@pytest.mark.platform_x86_cpu
+@pytest.mark.platform_arm_cpu
+@pytest.mark.platform_x86_gpu_training
+@pytest.mark.env_onecard
+@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE])
+def test_interpolate_nearest_5d(mode):
+    """
+    Feature: interpolate
+    Description: Verify the result of interpolate nearest mode
+                1. 5D size
+                2. 5D scale_factor recompute_scale_factor=True
+                3. 5D scale_factor
+    Expectation: success
+    """
+    ms.set_context(mode=mode)
+    net = Net("nearest")
+
+    # 1. 5D(1, 1, 1, 4, 5) size=(2, 4, 3)
+    size = (2, 4, 3)
+    input_5d = np.array([[[[[0.4992, 0.743079, 0.570383, 0.942855, 0.833395],
+                            [0.645754, 0.485126, 0.957497, 0.933144, 0.556276],
+                            [0.298626, 0.594928, 0.150964, 0.447654, 0.267512],
+                            [0.46943, 0.419558, 0.665492, 0.414906, 0.708427]]]]], dtype=np.float32)
+    except_5d_1 = np.array([[[[[0.4992, 0.743079, 0.942855],
+                               [0.645754, 0.485126, 0.933144],
+                               [0.298626, 0.594928, 0.447654],
+                               [0.46943, 0.419558, 0.414906]],
+                              [[0.4992, 0.743079, 0.942855],
+                               [0.645754, 0.485126, 0.933144],
+                               [0.298626, 0.594928, 0.447654],
+                               [0.46943, 0.419558, 0.414906]]]]], dtype=np.float32)
+    output_5d_1 = net(Tensor(input_5d), size=size)
+    assert np.allclose(output_5d_1.asnumpy(), except_5d_1, atol=1e-5, rtol=1e-5)
+
+    scale_factor = (3., 0.4, 0.7)
+    # 2. 5D(1, 1, 1, 4, 5) scale_factor=(3, 0.4, 0.7) recompute_scale_factor=True
+    except_5d_2 = np.array([[[[[0.4992, 0.743079, 0.942855]],
+                              [[0.4992, 0.743079, 0.942855]],
+                              [[0.4992, 0.743079, 0.942855]]]]], dtype=np.float32)
+    output_5d_2 = net(Tensor(input_5d), scale_factor=scale_factor, recompute_scale_factor=True)
+    assert np.allclose(output_5d_2.asnumpy(), except_5d_2, atol=1e-5, rtol=1e-5)
+
+    # 3. 5D(1, 1, 1, 4, 5) scale_factor=(3, 0.4, 0.7)
+    except_5d_3 = np.array([[[[[0.4992, 0.743079, 0.570383]],
+                              [[0.4992, 0.743079, 0.570383]],
+                              [[0.4992, 0.743079, 0.570383]]]]], dtype=np.float32)
+    output_5d_3 = net(Tensor(input_5d), scale_factor=scale_factor)
+    assert np.allclose(output_5d_3.asnumpy(), except_5d_3, atol=1e-5, rtol=1e-5)