mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/dataset/vision/transforms.py

@@ -1,4 +1,4 @@
-# Copyright 2019-2024 Huawei Technologies Co., Ltd
+# Copyright 2019-2022 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.
@@ -101,22 +101,6 @@ class ImageTensorOperation(TensorOperation):
         raise NotImplementedError("ImageTensorOperation has to implement parse() method.")
 
 
-class VideoTensorOperation(TensorOperation):
-    """
-    Base class of Video Tensor Ops
-    """
-
-    def __call__(self, *input_tensor_list):
-        for tensor in input_tensor_list:
-            if not isinstance(tensor, np.ndarray):
-                raise TypeError(
-                    "Input should be ndarray, got {}.".format(type(tensor)))
-        return super().__call__(*input_tensor_list)
-
-    def parse(self):
-        raise NotImplementedError("VideoTensorOperation has to implement parse() method.")
-
-
 class AdjustBrightness(ImageTensorOperation, PyTensorOperation):
     """
     Adjust the brightness of the input image.
@@ -647,8 +631,6 @@ class AdjustSharpness(ImageTensorOperation):
     """
     Adjust the sharpness of the input image.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         sharpness_factor (float): How much to adjust the sharpness, must be
             non negative. ``0`` gives a blurred image, ``1`` gives the
@@ -660,7 +642,7 @@ class AdjustSharpness(ImageTensorOperation):
         RuntimeError: If shape of the input image is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -695,56 +677,8 @@ class AdjustSharpness(ImageTensorOperation):
         self.sharpness_factor = sharpness_factor
         self.implementation = Implementation.C
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> # create a dataset that reads all files in dataset_dir with 8 threads
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> transforms_list = [vision.AdjustSharpness(sharpness_factor=2.0).device("Ascend")]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.AdjustSharpness(sharpness_factor=0).device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.AdjustSharpnessOperation(self.sharpness_factor, self.device_target)
+        return cde.AdjustSharpnessOperation(self.sharpness_factor)
 
 
 class Affine(ImageTensorOperation):
@@ -778,7 +712,7 @@ class Affine(ImageTensorOperation):
         RuntimeError: If shape of the input image is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -874,8 +808,6 @@ class Affine(ImageTensorOperation):
               <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
-        if self.resample not in [Inter.BILINEAR, Inter.NEAREST] and self.device_target == "Ascend":
-            raise RuntimeError("Invalid interpolation mode, only support BILINEAR and NEAREST.")
         return self
 
     def parse(self):
@@ -966,8 +898,6 @@ class AutoContrast(ImageTensorOperation, PyTensorOperation):
     Apply automatic contrast on input image. This operation calculates histogram of image, reassign cutoff percent
     of the lightest pixels from histogram to 255, and reassign cutoff percent of the darkest pixels from histogram to 0.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         cutoff (float, optional): Percent of lightest and darkest pixels to cut off from
             the histogram of input image. The value must be in the range [0.0, 50.0]. Default: ``0.0``.
@@ -982,7 +912,7 @@ class AutoContrast(ImageTensorOperation, PyTensorOperation):
         RuntimeError: If given tensor shape is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1021,56 +951,8 @@ class AutoContrast(ImageTensorOperation, PyTensorOperation):
         self.ignore = ignore
         self.random = False
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
-          If the data type is float32, the expected input value is in the range [0, 1].
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> transforms_list = [vision.AutoContrast(cutoff=10.0, ignore=[10, 20]).device("Ascend")]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.AutoContrast(cutoff=10.0, ignore=[10, 20]).device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.AutoContrastOperation(self.cutoff, self.ignore, self.device_target)
+        return cde.AutoContrastOperation(self.cutoff, self.ignore)
 
     def _execute_py(self, img):
         """
@@ -1244,8 +1126,6 @@ class ConvertColor(ImageTensorOperation):
     """
     Change the color space of the image.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         convert_mode (ConvertMode): The mode of image channel conversion.
 
@@ -1294,7 +1174,7 @@ class ConvertColor(ImageTensorOperation):
         RuntimeError: If given tensor shape is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1322,10 +1202,10 @@ class ConvertColor(ImageTensorOperation):
         (100, 100, 3) uint8
         >>>
         >>> # Use the transform in eager mode
-        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
         >>> output = vision.ConvertColor(vision.ConvertMode.COLOR_RGB2GRAY)(data)
         >>> print(output.shape, output.dtype)
-        (100, 100) uint8
+        (2, 2) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
@@ -1338,55 +1218,8 @@ class ConvertColor(ImageTensorOperation):
         self.convert_mode = convert_mode
         self.implementation = Implementation.C
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> transforms_list = [vision.ConvertColor(vision.ConvertMode.COLOR_RGB2BGR).device("Ascend")]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.ConvertColor(vision.ConvertMode.COLOR_RGB2BGR).device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.ConvertColorOperation(ConvertMode.to_c_type(self.convert_mode), self.device_target)
+        return cde.ConvertColorOperation(ConvertMode.to_c_type(self.convert_mode))
 
 
 class Crop(ImageTensorOperation):
@@ -1411,7 +1244,7 @@ class Crop(ImageTensorOperation):
         RuntimeError: If given tensor shape is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1821,67 +1654,15 @@ class Decode(ImageTensorOperation, PyTensorOperation):
         return util.decode(img)
 
 
-class DecodeVideo(VideoTensorOperation):
-    """
-    Decode the input raw video bytes.
-
-    Supported video formats: AVI, H264, H265, MOV, MP4, WMV.
-
-    Raises:
-        RuntimeError: If the input ndarray is not 1D array.
-        RuntimeError: If data type of the elements is not uint8.
-        RuntimeError: If the input ndarray is empty.
-
-    Supported Platforms:
-        ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore.dataset as ds
-        >>> import mindspore.dataset.vision as vision
-        >>>
-        >>> # Use the transform in dataset pipeline mode
-        >>> # Custom class to generate and read video dataset
-        >>> class VideoDataset:
-        ...     def __init__(self, file_list):
-        ...         self.file_list = file_list
-        ...
-        ...     def __getitem__(self, index):
-        ...         filename = self.file_list[index]
-        ...         return np.fromfile(filename, np.uint8)
-        ...
-        ...     def __len__(self):
-        ...         return len(self.file_list)
-        >>>
-        >>> dataset = ds.GeneratorDataset(VideoDataset(["/path/to/video/file"]), ["data"])
-        >>> decode_video = vision.DecodeVideo()
-        >>> dataset = dataset.map(operations=[decode_video], input_columns=["data"], output_columns=["video", "audio"])
-        >>>
-        >>> # Use the transform in eager mode
-        >>> filename = "/path/to/video/file"
-        >>> raw_ndarray = np.fromfile(filename, np.uint8)
-        >>> mindspore_output = vision.DecodeVideo()(raw_ndarray)
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.implementation = Implementation.C
-
-    def parse(self):
-        return cde.DecodeVideoOperation()
-
-
 class Equalize(ImageTensorOperation, PyTensorOperation):
     """
     Apply histogram equalization on input image.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Raises:
         RuntimeError: If given tensor shape is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -1913,55 +1694,8 @@ class Equalize(ImageTensorOperation, PyTensorOperation):
         super().__init__()
         self.random = False
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> transforms_list = [vision.Equalize().device("Ascend")]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.Equalize().device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.EqualizeOperation(self.device_target)
+        return cde.EqualizeOperation()
 
     def _execute_py(self, img):
         """
@@ -1981,16 +1715,14 @@ class Erase(ImageTensorOperation):
     """
     Erase the input image with given value.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         top (int): Vertical ordinate of the upper left corner of erased region.
         left (int): Horizontal ordinate of the upper left corner of erased region.
         height (int): Height of erased region.
         width (int): Width of erased region.
-        value (Union[float, Sequence[float, float, float]], optional): Pixel value used to pad the erased area.
-            Default: ``0``. If float is provided, it will be used for all RGB channels.
-            If Sequence[float, float, float] is provided, it will be used for R, G, B channels respectively.
+        value (Union[int, Sequence[int, int, int]], optional): Pixel value used to pad the erased area.
+            Default: ``0``. If int is provided, it will be used for all RGB channels.
+            If Sequence[int, int, int] is provided, it will be used for R, G, B channels respectively.
         inplace (bool, optional): Whether to apply erasing inplace. Default: ``False``.
 
     Raises:
@@ -2002,13 +1734,13 @@ class Erase(ImageTensorOperation):
         ValueError: If `height` is not positive.
         TypeError: If `width` is not of type int.
         ValueError: If `width` is not positive.
-        TypeError: If `value` is not of type float or Sequence[float, float, float].
+        TypeError: If `value` is not of type int or Sequence[int, int, int].
         ValueError: If `value` is not in range of [0, 255].
         TypeError: If `inplace` is not of type bool.
         RuntimeError: If shape of the input image is not <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -2026,10 +1758,10 @@ class Erase(ImageTensorOperation):
         (100, 100, 3) uint8
         >>>
         >>> # Use the transform in eager mode
-        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-        >>> output = vision.Erase(10, 10, 10, 10)(data)
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.Erase(0, 0, 2, 1)(data)
         >>> print(output.shape, output.dtype)
-        (100, 100, 3) uint8
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
@@ -2043,62 +1775,13 @@ class Erase(ImageTensorOperation):
         self.left = left
         self.height = height
         self.width = width
-        if isinstance(value, (int, float)):
-            value = tuple([value])
+        if isinstance(value, int):
+            value = tuple([value] * 3)
         self.value = value
         self.inplace = inplace
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type supports `uint8` or `float32` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-          The inplace parameter is not supported.
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> transforms_list = [vision.Erase(10, 10, 10, 10, (100, 100, 100)).device("Ascend")]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.Erase(10, 10, 10, 10, (100, 100, 100)).device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.EraseOperation(self.top, self.left, self.height, self.width, self.value, self.inplace,
-                                  self.device_target)
+        return cde.EraseOperation(self.top, self.left, self.height, self.width, self.value, self.inplace)
 
 
 class FiveCrop(PyTensorOperation):
@@ -2163,10 +1846,8 @@ class FiveCrop(PyTensorOperation):
         >>> img.save("./2.jpg")
         >>> data = Image.open("./2.jpg")
         >>> output = vision.FiveCrop(size=20)(data)
-        >>> for cropped_img in output:
-        ...     print(cropped_img.size)
-        ...     break
-        (20, 20)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (5,) object
         >>> os.remove("./2.jpg")
 
 
@@ -2223,7 +1904,7 @@ class GaussianBlur(ImageTensorOperation):
         RuntimeError: If given tensor shape is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -2413,13 +2094,11 @@ class HorizontalFlip(ImageTensorOperation):
     """
     Flip the input image horizontally.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Raises:
         RuntimeError: If given tensor shape is not <H, W> or <..., H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -2456,9 +2135,7 @@ class HorizontalFlip(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports  `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [4, 8192]
-          and a width limit of [6, 4096].
+        - When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
@@ -2627,13 +2304,11 @@ class Invert(ImageTensorOperation, PyTensorOperation):
     For each pixel in the image, if the original pixel value is `pixel`,
     the inverted pixel value will be `255 - pixel`.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Raises:
         RuntimeError: If the input image is not in shape of <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -2665,58 +2340,8 @@ class Invert(ImageTensorOperation, PyTensorOperation):
         super().__init__()
         self.random = False
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is CPU, input type only support `uint8` , input channel support 1/2/3.
-        - When the device is Ascend, input type supports  `uint8`/`float32`, input channel supports 1/3.
-          input shape should be limited from [4, 6] to [8192, 4096].
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>> from mindspore.dataset.vision import Inter
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> invert_op = vision.Invert()
-            >>> transforms_list = [invert_op]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.Invert().device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.InvertOperation(self.device_target)
+        return cde.InvertOperation()
 
     def _execute_py(self, img):
         """
@@ -3206,7 +2831,7 @@ class Pad(ImageTensorOperation, PyTensorOperation):
         RuntimeError: If given tensor shape is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -3391,8 +3016,6 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
     """
     Apply perspective transformation on input image.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         start_points (Sequence[Sequence[int, int]]): Sequence of the starting point coordinates, containing four
             two-element subsequences, corresponding to [top-left, top-right, bottom-right, bottom-left] of the
@@ -3410,7 +3033,7 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
         RuntimeError: If shape of the input image is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -3461,9 +3084,7 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [6, 8192]
-          and a width limit of [10, 4096].
+        - When the device is Ascend, input shape should be limited from [6, 10] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
@@ -3508,8 +3129,6 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
               <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
-        if self.interpolation not in [Inter.BILINEAR, Inter.NEAREST] and self.device_target == "Ascend":
-            raise RuntimeError("Invalid interpolation mode, only support BILINEAR and NEAREST.")
         return self
 
     def parse(self):
@@ -3538,8 +3157,6 @@ class Posterize(ImageTensorOperation):
     Reduce the bit depth of the color channels of image to create a high contrast and vivid color effect,
     similar to that seen in posters or printed materials.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         bits (int): The number of bits to keep for each channel, should be in range of [0, 8].
 
@@ -3580,56 +3197,8 @@ class Posterize(ImageTensorOperation):
         self.bits = bits
         self.implementation = Implementation.C
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type supports  `uint8`/`float32`, input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> posterize_op = vision.Posterize(4).device("Ascend")
-            >>> transforms_list = [posterize_op]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.Posterize(4).device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.PosterizeOperation(self.bits, self.device_target)
+        return cde.PosterizeOperation(self.bits)
 
 
 class RandAugment(ImageTensorOperation):
@@ -6096,8 +5665,9 @@ class Resize(ImageTensorOperation, PyTensorOperation):
               <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
-        if self.interpolation not in [Inter.BILINEAR, Inter.CUBIC, Inter.NEAREST] and self.device_target == "Ascend":
-            raise RuntimeError("Invalid interpolation mode, only support BILINEAR, CUBIC and NEAREST.")
+        if self.interpolation == Inter.ANTIALIAS and self.device_target == "Ascend":
+            raise ValueError("The current InterpolationMode is not supported by DVPP. It is {}."
+                             .format(self.interpolation))
         return self
 
     def parse(self):
@@ -6124,8 +5694,6 @@ class ResizedCrop(ImageTensorOperation):
     """
     Crop the input image at a specific region and resize it to desired size.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         top (int): Horizontal ordinate of the upper left corner of the crop region.
         left (int): Vertical ordinate of the upper left corner of the crop region.
@@ -6153,7 +5721,7 @@ class ResizedCrop(ImageTensorOperation):
         RuntimeError: If shape of the input image is not <H, W> or <H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -6201,9 +5769,7 @@ class ResizedCrop(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [4, 32768]
-          and a width limit of [6, 32768].
+        - When the device is Ascend, input/output shape should be limited from [4, 6] to [32768, 32768].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
@@ -6244,8 +5810,6 @@ class ResizedCrop(ImageTensorOperation):
               <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
-        if self.interpolation not in [Inter.BILINEAR, Inter.CUBIC, Inter.NEAREST] and self.device_target == "Ascend":
-            raise RuntimeError("Invalid interpolation mode, only support BILINEAR, CUBIC and NEAREST.")
         return self
 
     def parse(self):
@@ -6394,8 +5958,6 @@ class Rotate(ImageTensorOperation):
     """
     Rotate the input image by specified degrees.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         degrees (Union[int, float]): Rotation degrees.
         resample (Inter, optional): Image interpolation method defined by :class:`~.vision.Inter` .
@@ -6421,7 +5983,7 @@ class Rotate(ImageTensorOperation):
         RuntimeError: If given tensor shape is not <H, W> or <..., H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -6466,62 +6028,9 @@ class Rotate(ImageTensorOperation):
         self.fill_value = fill_value
         self.implementation = Implementation.C
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type supports  `uint8`/`float32`, input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-        - When the device is Ascend and `expand` is True, `center` does not take effect
-          and the image is rotated according to the center of the image.
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>> from mindspore.dataset.vision import Inter
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 300, 400, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> rotate_op = vision.Rotate(degrees=90.0, resample=Inter.NEAREST, expand=True).device("Ascend")
-            >>> transforms_list = [rotate_op]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (400, 300, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(300, 400, 3)).astype(np.uint8)
-            >>> output = vision.Rotate(degrees=90.0, resample=Inter.NEAREST, expand=True).device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (400, 300, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        if self.resample not in [Inter.BILINEAR, Inter.NEAREST] and self.device_target == "Ascend":
-            raise RuntimeError("Invalid interpolation mode, only support BILINEAR and NEAREST.")
-        return self
-
     def parse(self):
         return cde.RotateOperation(self.degrees, Inter.to_c_type(self.resample), self.expand, self.center,
-                                   self.fill_value, self.device_target)
+                                   self.fill_value)
 
 
 class SlicePatches(ImageTensorOperation):
@@ -6606,8 +6115,6 @@ class Solarize(ImageTensorOperation):
     """
     Solarize the image by inverting all pixel values within the threshold.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Args:
         threshold (Union[float, Sequence[float, float]]): Range of solarize threshold, should always
             be in (min, max) format, where min and max are integers in range of [0, 255], and min <= max.
@@ -6619,7 +6126,7 @@ class Solarize(ImageTensorOperation):
         ValueError: If `threshold` is not in range of [0, 255].
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -6655,56 +6162,8 @@ class Solarize(ImageTensorOperation):
         self.threshold = threshold
         self.implementation = Implementation.C
 
-    @check_device_target
-    def device(self, device_target="CPU"):
-        """
-        Set the device for the current operator execution.
-
-        - When the device is Ascend, input type only supports `uint8` , input channel supports 1 and 3.
-          The input data has a height limit of [4, 8192] and a width limit of [6, 4096].
-
-        Args:
-            device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
-
-        Raises:
-            TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
-
-        Supported Platforms:
-            ``CPU`` ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore.dataset as ds
-            >>> import mindspore.dataset.vision as vision
-            >>>
-            >>> # Use the transform in dataset pipeline mode
-            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
-            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
-            >>> solarize_op = vision.Solarize(threshold=(10, 100)).device("Ascend")
-            >>> transforms_list = [solarize_op]
-            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
-            >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
-            ...     print(item["image"].shape, item["image"].dtype)
-            ...     break
-            (100, 100, 3) uint8
-            >>>
-            >>> # Use the transform in eager mode
-            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
-            >>> output = vision.Solarize(threshold=(10, 100)).device("Ascend")(data)
-            >>> print(output.shape, output.dtype)
-            (100, 100, 3) uint8
-
-        Tutorial Examples:
-            - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/master/api_python/samples/dataset/vision_gallery.html>`_
-        """
-        self.device_target = device_target
-        return self
-
     def parse(self):
-        return cde.SolarizeOperation(self.threshold, self.device_target)
+        return cde.SolarizeOperation(self.threshold)
 
 
 class TenCrop(PyTensorOperation):
@@ -7195,13 +6654,11 @@ class VerticalFlip(ImageTensorOperation):
     """
     Flip the input image vertically.
 
-    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
-
     Raises:
         RuntimeError: If given tensor shape is not <H, W> or <..., H, W, C>.
 
     Supported Platforms:
-        ``CPU`` ``Ascend``
+        ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -7238,9 +6695,7 @@ class VerticalFlip(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
-        - When the device is Ascend, input type supports `uint8` and `float32`,
-          input channel supports 1 and 3. The input data has a height limit of [4, 8192]
-          and a width limit of [6, 4096].
+        - When the device is Ascend, input shape should be limited from [4, 6] to [8192, 4096].
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports