mindspore 2.2.11__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl

mindspore/dataset/vision/transforms.py

@@ -105,6 +105,8 @@ class AdjustBrightness(ImageTensorOperation, PyTensorOperation):
     """
     Adjust the brightness of the input image.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         brightness_factor (float): How much to adjust the brightness, must be non negative.
             ``0`` gives a black image, ``1`` gives the original image,
@@ -119,17 +121,30 @@ class AdjustBrightness(ImageTensorOperation, PyTensorOperation):
         ``CPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.AdjustBrightness(brightness_factor=2.0)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.AdjustBrightness(brightness_factor=2.0)]
+        >>> 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, 256, (20, 20, 3)) / 255.0
+        >>> data = data.astype(np.float32)
+        >>> output = vision.AdjustBrightness(2.666)(data)
+        >>> print(output.shape, output.dtype)
+        (20, 20, 3) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_adjust_brightness
@@ -142,28 +157,44 @@ class AdjustBrightness(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
+        - 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
-                ``CPU`` . Default: ``CPU`` .
+                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not ``CPU`` .
+            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
 
         Supported Platforms:
-            ``CPU``
+            ``CPU`` ``Ascend``
 
         Examples:
+            >>> import numpy as np
             >>> import mindspore.dataset as ds
             >>> import mindspore.dataset.vision as vision
             >>>
-            >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-            >>> transforms_list = [vision.Decode().device("CPU"), vision.AdjustBrightness(2.0).device("Ascend")]
-            >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list, input_columns=["image"])
+            >>> # 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.AdjustBrightness(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, 256, (20, 20, 3)) / 255.0
+            >>> data = data.astype(np.float32)
+            >>> output = vision.AdjustBrightness(2.666).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (20, 20, 3) float32
 
         Tutorial Examples:
             - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
         return self
@@ -188,6 +219,8 @@ class AdjustContrast(ImageTensorOperation, PyTensorOperation):
     """
     Adjust the contrast of the input image.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         contrast_factor (float): How much to adjust the contrast, must be non negative.
             ``0`` gives a solid gray image, ``1`` gives the original image,
@@ -202,17 +235,29 @@ class AdjustContrast(ImageTensorOperation, PyTensorOperation):
         ``CPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.AdjustContrast(contrast_factor=2.0)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.AdjustContrast(contrast_factor=2.0)]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.AdjustContrast(2.0)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_adjust_contrast
@@ -225,28 +270,43 @@ class AdjustContrast(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
+        - 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
-                ``CPU`` . Default: ``CPU`` .
+                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not ``CPU`` .
+            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
 
         Supported Platforms:
-            ``CPU``
+            ``CPU`` ``Ascend``
 
         Examples:
+            >>> import numpy as np
             >>> import mindspore.dataset as ds
             >>> import mindspore.dataset.vision as vision
             >>>
-            >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-            >>> transforms_list = [vision.Decode().device("CPU"), vision.AdjustContrast(0).device("Ascend")]
-            >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list, input_columns=["image"])
+            >>> # 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.AdjustContrast(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.AdjustContrast(2.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/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
         return self
@@ -295,17 +355,29 @@ class AdjustGamma(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.AdjustGamma(gamma=10.0, gain=1.0)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.AdjustGamma(gamma=10.0, gain=1.0)]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.AdjustGamma(gamma=0.1, gain=1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_adjust_gamma
@@ -335,6 +407,8 @@ class AdjustHue(ImageTensorOperation, PyTensorOperation):
     """
     Adjust the hue of the input image.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         hue_factor (float): How much to add to the hue channel,
             must be in range of [-0.5, 0.5].
@@ -348,17 +422,29 @@ class AdjustHue(ImageTensorOperation, PyTensorOperation):
         ``CPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.AdjustHue(hue_factor=0.2)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.AdjustHue(hue_factor=0.2)]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.AdjustHue(hue_factor=0.2)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_adjust_hue
@@ -371,28 +457,43 @@ class AdjustHue(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
+        - 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
-                ``CPU`` . Default: ``CPU`` .
+                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not ``CPU`` .
+            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
 
         Supported Platforms:
-            ``CPU``
+            ``CPU`` ``Ascend``
 
         Examples:
+            >>> import numpy as np
             >>> import mindspore.dataset as ds
             >>> import mindspore.dataset.vision as vision
             >>>
-            >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-            >>> transforms_list = [vision.Decode().device("CPU"), vision.AdjustHue(0.5).device("Ascend")]
-            >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list, input_columns=["image"])
+            >>> # 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.AdjustHue(0.5).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.AdjustHue(hue_factor=0.2).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (100, 100, 3) uint8
 
         Tutorial Examples:
             - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
         return self
@@ -417,6 +518,8 @@ class AdjustSaturation(ImageTensorOperation, PyTensorOperation):
     """
     Adjust the saturation of the input image.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         saturation_factor (float): How much to adjust the saturation, must be non negative.
             ``0`` gives a black image, ``1`` gives the original image
@@ -432,17 +535,29 @@ class AdjustSaturation(ImageTensorOperation, PyTensorOperation):
         ``CPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.AdjustSaturation(saturation_factor=2.0)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.AdjustSaturation(saturation_factor=2.0)]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.AdjustSaturation(saturation_factor=2.0)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_adjust_saturation
@@ -455,28 +570,43 @@ class AdjustSaturation(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
+        - 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
-                ``CPU`` . Default: ``CPU`` .
+                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not ``CPU`` .
+            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
 
         Supported Platforms:
-            ``CPU``
+            ``CPU`` ``Ascend``
 
         Examples:
+            >>> import numpy as np
             >>> import mindspore.dataset as ds
             >>> import mindspore.dataset.vision as vision
             >>>
-            >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-            >>> transforms_list = [vision.Decode().device("CPU"), vision.AdjustSaturation(2.0).device("Ascend")]
-            >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list, input_columns=["image"])
+            >>> # 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.AdjustSaturation(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.AdjustSaturation(saturation_factor=2.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/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
         return self
@@ -515,17 +645,30 @@ class AdjustSharpness(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.AdjustSharpness(sharpness_factor=2.0)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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)]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((3, 4))
+        >>> output = vision.AdjustSharpness(sharpness_factor=0)(data)
+        >>> print(output.shape, output.dtype)
+        (3, 4) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_adjust_sharpness
@@ -542,9 +685,12 @@ class Affine(ImageTensorOperation):
     """
     Apply Affine transformation to the input image, keeping the center of the image unchanged.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         degrees (float): Rotation angle in degrees between -180 and 180, clockwise direction.
-        translate (Sequence[float, float]): The horizontal and vertical translations, must be a sequence of size 2.
+        translate (Sequence[float, float]): The horizontal and vertical translations, must be a sequence of size 2
+            and value between -1 and 1.
         scale (float): Scaling factor, which must be positive.
         shear (Union[float, Sequence[float, float]]): Shear angle value in degrees between -180 to 180.
             If float is provided, shear along the x axis with this value, without shearing along the y axis;
@@ -569,21 +715,32 @@ class Affine(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> decode_op = vision.Decode()
+        >>> # 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"])
         >>> affine_op = vision.Affine(degrees=15, translate=[0.2, 0.2], scale=1.1, shear=[1.0, 1.0],
         ...                           resample=Inter.BILINEAR)
-        >>> affine_list = [decode_op, affine_op]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[affine_op], 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
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=affine_list, input_columns=["image"])
+        >>> # Use the transform in eager mode
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.Affine(degrees=15, translate=[0.2, 0.2], scale=1.1,
+        ...                        shear=[1.0, 1.0], resample=Inter.BILINEAR)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_affine
@@ -604,9 +761,58 @@ class Affine(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 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
+                ``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"])
+            >>> affine_op = vision.Affine(degrees=15, translate=[0.2, 0.2], scale=1.1,
+            ...                           shear=[1.0, 1.0], resample=Inter.BILINEAR).device("Ascend")
+            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[affine_op], 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.Affine(degrees=15, translate=[0.2, 0.2], scale=1.1,
+            ...                        shear=[1.0, 1.0], resample=Inter.BILINEAR).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (100, 100, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        return self
+
     def parse(self):
         return cde.AffineOperation(self.degrees, self.translate, self.scale_, self.shear,
-                                   Inter.to_c_type(self.resample), self.fill_value)
+                                   Inter.to_c_type(self.resample), self.fill_value, self.device_target)
 
 
 class AutoAugment(ImageTensorOperation):
@@ -644,21 +850,32 @@ class AutoAugment(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import AutoAugmentPolicy, Inter
         >>>
-        >>> transforms_list = [vision.Decode(), vision.AutoAugment(policy=AutoAugmentPolicy.IMAGENET,
-        ...                                                        interpolation=Inter.NEAREST,
-        ...                                                        fill_value=0)]
+        >>> # Use the transform in dataset pipeline mode
+        >>> transforms_list = [vision.AutoAugment(policy=AutoAugmentPolicy.IMAGENET,
+        ...                                       interpolation=Inter.NEAREST,
+        ...                                       fill_value=0)]
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.AutoAugment()(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_auto_augment
@@ -698,17 +915,29 @@ class AutoContrast(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.AutoContrast(cutoff=10.0, ignore=[10, 20])]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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])]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.AutoContrast(cutoff=10.0, ignore=[10, 20])(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_auto_contrast
@@ -758,20 +987,44 @@ class BoundingBoxAugment(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(np.float32))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[func],
+        ...                                                 input_columns=["image"],
+        ...                                                 output_columns=["image", "bbox"])
         >>> # set bounding box operation with ratio of 1 to apply rotation on all bounding boxes
         >>> bbox_aug_op = vision.BoundingBoxAugment(vision.RandomRotation(90), 1)
         >>> # map to apply ops
-        >>> image_folder_dataset = image_folder_dataset.map(operations=[bbox_aug_op],
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[bbox_aug_op],
         ...                                                 input_columns=["image", "bbox"],
         ...                                                 output_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (100, 100, 3) float32
+        (1, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((3, 4))
+        >>> data = data.astype(np.float32)
+        >>> func = lambda img, bboxes: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(bboxes.dtype))
+        >>> func_data, func_bboxes = func(data, data)
+        >>> output = vision.BoundingBoxAugment(transforms.Fill(100), 1.0)(func_data, func_bboxes)
+        >>> print(output[0].shape, output[0].dtype)
+        (3, 4) float32
+        >>> print(output[1].shape, output[1].dtype)
+        (1, 4) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_bounding_box_augment_cpp
@@ -809,23 +1062,40 @@ class CenterCrop(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # 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"])
         >>>
         >>> # crop image to a square
-        >>> transforms_list1 = [vision.Decode(), vision.CenterCrop(50)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list1 = [vision.CenterCrop(50)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list1, 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
+        (50, 50, 3) uint8
+        >>>
         >>> # crop image to portrait style
-        >>> transforms_list2 = [vision.Decode(), vision.CenterCrop((60, 40))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list2,
-        ...                                                 input_columns=["image"])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> transforms_list2 = [vision.CenterCrop((60, 40))]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list2, 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
+        (60, 40, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.CenterCrop(1)(data)
+        >>> print(output.shape, output.dtype)
+        (1, 1, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_center_crop
@@ -907,23 +1177,39 @@ class ConvertColor(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # 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"])
         >>>
         >>> # Convert RGB images to GRAY images
         >>> convert_op = vision.ConvertColor(vision.ConvertMode.COLOR_RGB2GRAY)
-        >>> image_folder_dataset = image_folder_dataset.map(operations=convert_op,
-        ...                                                 input_columns=["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=convert_op, 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) uint8
         >>> # Convert RGB images to BGR images
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
         >>> convert_op = vision.ConvertColor(vision.ConvertMode.COLOR_RGB2BGR)
-        >>> image_folder_dataset = image_folder_dataset.map(operations=convert_op,
-        ...                                                 input_columns=["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=convert_op, 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.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)
+        (2, 2) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_convert_color
@@ -940,6 +1226,8 @@ class Crop(ImageTensorOperation):
     """
     Crop the input image at a specific location.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         coordinates(sequence): Coordinates of the upper left corner of the cropping image. Must be a sequence of two
             values, in the form of (top, left).
@@ -959,19 +1247,30 @@ class Crop(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> decode_op = vision.Decode()
+        >>> # 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"])
         >>> crop_op = vision.Crop((0, 0), 32)
-        >>> transforms_list = [decode_op, crop_op]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [crop_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
+        (32, 32, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.Crop((0, 0), 1)(data)
+        >>> print(output.shape, output.dtype)
+        (1, 1, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_crop
@@ -983,8 +1282,55 @@ class Crop(ImageTensorOperation):
         self.size = size
         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/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
+                ``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"])
+            >>> crop_op = vision.Crop((0, 0), (100, 75)).device("Ascend")
+            >>> transforms_list = [crop_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, 75, 3) uint8
+            >>>
+            >>> # Use the transform in eager mode
+            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+            >>> output = vision.Crop((0, 0), 64).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (64, 64, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        return self
+
     def parse(self):
-        return cde.CropOperation(self.coordinates, self.size)
+        return cde.CropOperation(self.coordinates, self.size, self.device_target)
 
 
 class CutMixBatch(ImageTensorOperation):
@@ -1011,23 +1357,44 @@ class CutMixBatch(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
-        >>> import mindspore.dataset.vision as vision
         >>> import mindspore.dataset.transforms as transforms
+        >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import ImageBatchFormat
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(28, 28, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(
+        ...     operations=lambda img: (data, np.random.randint(0, 5, (3, 1))),
+        ...     input_columns=["image"],
+        ...     output_columns=["image", "label"])
         >>> onehot_op = transforms.OneHot(num_classes=10)
-        >>> image_folder_dataset= image_folder_dataset.map(operations=onehot_op,
-        ...                                                input_columns=["label"])
+        >>> numpy_slices_dataset= numpy_slices_dataset.map(operations=onehot_op, input_columns=["label"])
         >>> cutmix_batch_op = vision.CutMixBatch(ImageBatchFormat.NHWC, 1.0, 0.5)
-        >>> image_folder_dataset = image_folder_dataset.batch(5)
-        >>> image_folder_dataset = image_folder_dataset.map(operations=cutmix_batch_op,
+        >>> numpy_slices_dataset = numpy_slices_dataset.batch(5)
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=cutmix_batch_op,
         ...                                                 input_columns=["image", "label"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["label"].shape, item["label"].dtype)
+        ...     break
+        (5, 28, 28, 3) uint8
+        (5, 3, 10) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, (3, 3, 10, 10)).astype(np.uint8)
+        >>> label = np.array([[0, 1], [1, 0], [1, 0]])
+        >>> output = vision.CutMixBatch(vision.ImageBatchFormat.NCHW, 1.0, 1.0)(data, label)
+        >>> print(output[0].shape, output[0].dtype)
+        (3, 3, 10, 10) uint8
+        >>> print(output[1].shape, output[1].dtype)
+        (3, 2) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_cut_mix_batch_c
@@ -1064,17 +1431,29 @@ class CutOut(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.CutOut(80, num_patches=10)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.CutOut(80, num_patches=10)]
+        >>> 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.CutOut(20)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_cutout_new
@@ -1095,6 +1474,8 @@ class Decode(ImageTensorOperation, PyTensorOperation):
     Decode the input image in RGB mode.
     Supported image formats: JPEG, BMP, PNG, TIFF, GIF(need `to_pil=True` ), WEBP(need `to_pil=True` ).
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         to_pil (bool, optional): Whether to decode the image to the PIL data type. If ``True``,
             the image will be decoded to the PIL data type, otherwise it will be decoded to the
@@ -1109,23 +1490,53 @@ class Decode(ImageTensorOperation, PyTensorOperation):
         ``CPU`` ``Ascend``
 
     Examples:
+        >>> import os
+        >>> import numpy as np
+        >>> from PIL import Image, ImageDraw
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> # Eager usage
-        >>> import numpy as np
-        >>> raw_image = np.fromfile("/path/to/image/file", np.uint8)
-        >>> decoded_image = vision.Decode()(raw_image)
+        >>> # Use the transform in dataset pipeline mode
+        >>> class MyDataset:
+        ...     def __init__(self):
+        ...         self.data = []
+        ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+        ...         draw = ImageDraw.Draw(img)
+        ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+        ...         img.save("./1.jpg")
+        ...         data = np.fromfile("./1.jpg", np.uint8)
+        ...         self.data.append(data)
+        ...
+        ...     def __getitem__(self, index):
+        ...         return self.data[0]
+        ...
+        ...     def __len__(self):
+        ...         return 5
         >>>
-        >>> # Pipeline usage
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> my_dataset = MyDataset()
+        >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
         >>> transforms_list = [vision.Decode(), vision.RandomHorizontalFlip()]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns=["image"])
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (300, 300, 3) uint8
+        >>> os.remove("./1.jpg")
+        >>>
+        >>> # Use the transform in eager mode
+        >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+        >>> draw = ImageDraw.Draw(img)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+        >>> img.save("./2.jpg")
+        >>> data = np.fromfile("./2.jpg", np.uint8)
+        >>> output = vision.Decode()(data)
+        >>> print(output.shape, output.dtype)
+        (300, 300, 3) uint8
+        >>> os.remove("./2.jpg")
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_decode
@@ -1159,31 +1570,71 @@ class Decode(ImageTensorOperation, PyTensorOperation):
 
         Args:
             device_target (str, optional): The operator will be executed on this device. Currently supports
-                ``CPU`` . Default: ``CPU`` .
+                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not ``CPU`` .
+            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
 
         Supported Platforms:
-            ``CPU``
+            ``CPU`` ``Ascend``
 
         Examples:
+            >>> import os
+            >>> import numpy as np
+            >>> from PIL import Image, ImageDraw
             >>> import mindspore.dataset as ds
             >>> import mindspore.dataset.vision as vision
             >>> from mindspore.dataset.vision import Inter
             >>>
+            >>> # Use the transform in dataset pipeline mode
+            >>> class MyDataset:
+            ...     def __init__(self):
+            ...         self.data = []
+            ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+            ...         draw = ImageDraw.Draw(img)
+            ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+            ...         img.save("./1.jpg")
+            ...         data = np.fromfile("./1.jpg", np.uint8)
+            ...         self.data.append(data)
+            ...
+            ...     def __getitem__(self, index):
+            ...         return self.data[0]
+            ...
+            ...     def __len__(self):
+            ...         return 5
+            >>>
+            >>> my_dataset = MyDataset()
+            >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
             >>> decode_op = vision.Decode().device("Ascend")
             >>> resize_op = vision.Resize([100, 75], Inter.BICUBIC)
             >>> transforms_list = [decode_op, resize_op]
-            >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-            >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-            ...                                                 input_columns=["image"])
+            >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns=["image"])
+            >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+            ...     print(item["image"].shape, item["image"].dtype)
+            ...     break
+            (100, 75, 3) uint8
+            >>> os.remove("./1.jpg")
+            >>>
+            >>> # Use the transform in eager mode
+            >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+            >>> draw = ImageDraw.Draw(img)
+            >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+            >>> img.save("./2.jpg")
+            >>> data = np.fromfile("./2.jpg", np.uint8)
+            >>> output = vision.Decode().device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (300, 300, 3) uint8
+            >>> os.remove("./2.jpg")
 
         Tutorial Examples:
             - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
         """
+        if self.implementation == Implementation.PY and device_target == "Ascend":
+            raise ValueError("The transform \"Decode(to_pil=True)\" cannot be performed on Ascend device, " +
+                             "please set \"to_pil=False\".")
+
         self.device_target = device_target
         return self
 
@@ -1214,17 +1665,29 @@ class Equalize(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.Equalize()]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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()]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.Equalize()(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     def __init__(self):
@@ -1280,17 +1743,29 @@ class Erase(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.Erase(10,10,10,10)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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)]
+        >>> 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.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)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_erase
@@ -1326,23 +1801,59 @@ class FiveCrop(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import os
+        >>> import numpy as np
+        >>> from PIL import Image, ImageDraw
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
-        >>> import numpy
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> class MyDataset:
+        ...     def __init__(self):
+        ...         self.data = []
+        ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+        ...         draw = ImageDraw.Draw(img)
+        ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+        ...         img.save("./1.jpg")
+        ...         data = np.fromfile("./1.jpg", np.uint8)
+        ...         self.data.append(data)
+        ...
+        ...     def __getitem__(self, index):
+        ...         return self.data[0]
+        ...
+        ...     def __len__(self):
+        ...         return 5
+        >>>
+        >>> my_dataset = MyDataset()
+        >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
         >>> transforms_list = Compose([vision.Decode(to_pil=True),
         ...                            vision.FiveCrop(size=200),
         ...                            # 4D stack of 5 images
-        ...                            lambda *images: numpy.stack([vision.ToTensor()(image) for image in images])])
+        ...                            lambda *images: np.stack([vision.ToTensor()(image) for image in images])])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns="image")
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (5, 3, 200, 200) float32
+        >>> os.remove("./1.jpg")
+        >>>
+        >>> # Use the transform in eager mode
+        >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+        >>> draw = ImageDraw.Draw(img)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+        >>> img.save("./2.jpg")
+        >>> data = Image.open("./2.jpg")
+        >>> output = vision.FiveCrop(size=20)(data)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (5,) object
+        >>> os.remove("./2.jpg")
+
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_five_crop
@@ -1369,6 +1880,8 @@ class GaussianBlur(ImageTensorOperation):
     r"""
     Blur input image with the specified Gaussian kernel.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         kernel_size (Union[int, Sequence[int, int]]): The size of the Gaussian kernel. Must be positive and odd.
             If the input type is int, the value will be used as both the width and height of the Gaussian kernel.
@@ -1394,17 +1907,29 @@ class GaussianBlur(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(to_pil=True), vision.GaussianBlur(3, 3)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.GaussianBlur(3, 3)]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.GaussianBlur(3, 3)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_gaussian_blur
@@ -1420,8 +1945,60 @@ class GaussianBlur(ImageTensorOperation):
         self.sigma = sigma
         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, the parameter `kernel_size` only supports values 1, 3, and 5.
+          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
+            >>>
+            >>> # 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"])
+            >>> blur_op = vision.GaussianBlur(3, 3).device("Ascend")
+            >>> transforms_list = [blur_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.GaussianBlur(3, 3).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (100, 100, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        if device_target == "Ascend":
+            for k in self.kernel_size:
+                if k not in [1, 3, 5]:
+                    raise RuntimeError("When target is Ascend, `kernel_size` only supports values 1, 3, and 5.")
+        return self
+
     def parse(self):
-        return cde.GaussianBlurOperation(self.kernel_size, self.sigma)
+        return cde.GaussianBlurOperation(self.kernel_size, self.sigma, self.device_target)
 
 
 class Grayscale(PyTensorOperation):
@@ -1440,21 +2017,57 @@ class Grayscale(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import os
+        >>> import numpy as np
+        >>> from PIL import Image, ImageDraw
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> class MyDataset:
+        ...     def __init__(self):
+        ...         self.data = []
+        ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+        ...         draw = ImageDraw.Draw(img)
+        ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+        ...         img.save("./1.jpg")
+        ...         data = np.fromfile("./1.jpg", np.uint8)
+        ...         self.data.append(data)
+        ...
+        ...     def __getitem__(self, index):
+        ...         return self.data[0]
+        ...
+        ...     def __len__(self):
+        ...         return 5
+        >>>
+        >>> my_dataset = MyDataset()
+        >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
         >>> transforms_list = Compose([vision.Decode(to_pil=True),
         ...                            vision.Grayscale(3),
         ...                            vision.ToTensor()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns="image")
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 300, 300) float32
+        >>> os.remove("./1.jpg")
+        >>>
+        >>> # Use the transform in eager mode
+        >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+        >>> draw = ImageDraw.Draw(img)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+        >>> img.save("./2.jpg")
+        >>> data = Image.open("./2.jpg")
+        >>> output = vision.Grayscale(3)(data)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (300, 300, 3) uint8
+        >>> os.remove("./2.jpg")
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_num_channels
@@ -1488,25 +2101,84 @@ class HorizontalFlip(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(to_pil=True), vision.HorizontalFlip()]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.HorizontalFlip()]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.HorizontalFlip()(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     def __init__(self):
         super().__init__()
         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 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
+            >>>
+            >>> # 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"])
+            >>> horizontal_flip_op = vision.HorizontalFlip().device("Ascend")
+            >>> transforms_list = [horizontal_flip_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.HorizontalFlip().device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (100, 100, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        return self
+
     def parse(self):
-        return cde.HorizontalFlipOperation()
+        return cde.HorizontalFlipOperation(self.device_target)
 
 
 class HsvToRgb(PyTensorOperation):
@@ -1524,22 +2196,33 @@ class HsvToRgb(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
-        >>> transforms_list = Compose([vision.Decode(to_pil=True),
-        ...                            vision.CenterCrop(20),
+        >>> # Use the transform in dataset pipeline mode
+        >>> transforms_list = Compose([vision.CenterCrop(20),
         ...                            vision.ToTensor(),
         ...                            vision.HsvToRgb()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (3, 20, 20) float64
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.HsvToRgb(is_hwc=True)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) float64
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_hsv_to_rgb
@@ -1578,20 +2261,31 @@ class HWC2CHW(ImageTensorOperation):
         ``CPU`` ``GPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(),
-        ...                    vision.RandomHorizontalFlip(0.75),
-        ...                    vision.RandomCrop(512),
+        >>> # 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.RandomHorizontalFlip(0.75),
+        ...                    vision.RandomCrop(64),
         ...                    vision.HWC2CHW()]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> 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
+        (3, 64, 64) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.HWC2CHW()(data)
+        >>> print(output.shape, output.dtype)
+        (3, 2, 2) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     def __init__(self):
@@ -1617,17 +2311,29 @@ class Invert(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.Invert()]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.Invert()]
+        >>> 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.array([[0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 2, 3))
+        >>> output = vision.Invert()(data)
+        >>> print(output.shape, output.dtype)
+        (2, 2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     def __init__(self):
@@ -1671,27 +2377,39 @@ class LinearTransformation(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
-        >>> import numpy as np
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> height, width = 32, 32
         >>> dim = 3 * height * width
         >>> transformation_matrix = np.ones([dim, dim])
         >>> mean_vector = np.zeros(dim)
-        >>> transforms_list = Compose([vision.Decode(to_pil=True),
-        ...                            vision.Resize((height,width)),
+        >>> transforms_list = Compose([vision.Resize((height,width)),
         ...                            vision.ToTensor(),
         ...                            vision.LinearTransformation(transformation_matrix, mean_vector)])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (3, 32, 32) float64
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randn(10, 10, 3)
+        >>> transformation_matrix = np.random.randn(300, 300)
+        >>> mean_vector = np.random.randn(300,)
+        >>> output = vision.LinearTransformation(transformation_matrix, mean_vector)(data)
+        >>> print(output.shape, output.dtype)
+        (10, 10, 3) float64
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_linear_transform
@@ -1741,28 +2459,45 @@ class MixUp(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> import mindspore.dataset.transforms as transforms
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> # first decode the image
-        >>> image_folder_dataset = image_folder_dataset.map(operations=vision.Decode(),
-        ...                                                 input_columns="image")
-        >>> # then ont hot decode the label
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms.OneHot(10),
-        ...                                                 input_columns="label")
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(64, 64, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(
+        ...     operations=lambda img: (data, np.random.randint(0, 5, (3, 1))),
+        ...     input_columns=["image"],
+        ...     output_columns=["image", "label"])
+        >>> # ont hot decode the label
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.OneHot(10), input_columns="label")
         >>> # batch the samples
-        >>> batch_size = 4
-        >>> image_folder_dataset = image_folder_dataset.batch(batch_size=batch_size)
+        >>> numpy_slices_dataset = numpy_slices_dataset.batch(batch_size=4)
         >>> # finally mix up the images and labels
-        >>> image_folder_dataset = image_folder_dataset.map(
-        ...     operations=vision.MixUp(batch_size=batch_size, alpha=0.2),
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(
+        ...     operations=vision.MixUp(batch_size=1, alpha=0.2),
         ...     input_columns=["image", "label"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["label"].shape, item["label"].dtype)
+        ...     break
+        (4, 64, 64, 3) float64
+        (4, 3, 10) float64
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> label = np.array([[0, 1]])
+        >>> output = vision.MixUp(batch_size=2, alpha=0.2, is_single=False)(data, label)
+        >>> print(output[0].shape, output[0].dtype)
+        (2, 100, 100, 3) float64
+        >>> print(output[1].shape, output[1].dtype)
+        (2, 2) float64
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_mix_up
@@ -1820,22 +2555,44 @@ class MixUpBatch(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> import mindspore.dataset.transforms as transforms
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(64, 64, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(
+        ...     operations=lambda img: (data, np.random.randint(0, 5, (3, 1))),
+        ...     input_columns=["image"],
+        ...     output_columns=["image", "label"])
         >>> onehot_op = transforms.OneHot(num_classes=10)
-        >>> image_folder_dataset= image_folder_dataset.map(operations=onehot_op,
+        >>> numpy_slices_dataset= numpy_slices_dataset.map(operations=onehot_op,
         ...                                                input_columns=["label"])
         >>> mixup_batch_op = vision.MixUpBatch(alpha=0.9)
-        >>> image_folder_dataset = image_folder_dataset.batch(5)
-        >>> image_folder_dataset = image_folder_dataset.map(operations=mixup_batch_op,
+        >>> numpy_slices_dataset = numpy_slices_dataset.batch(5)
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=mixup_batch_op,
         ...                                                 input_columns=["image", "label"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["label"].shape, item["label"].dtype)
+        ...     break
+        (5, 64, 64, 3) uint8
+        (5, 3, 10) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, (2, 10, 10, 3)).astype(np.uint8)
+        >>> label = np.array([[0, 1], [1, 0]])
+        >>> output = vision.MixUpBatch(1)(data, label)
+        >>> print(output[0].shape, output[0].dtype)
+        (2, 10, 10, 3) uint8
+        >>> print(output[1].shape, output[1].dtype)
+        (2, 2) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_mix_up_batch_c
@@ -1853,6 +2610,8 @@ class Normalize(ImageTensorOperation):
     Normalize the input image with respect to mean and standard deviation. This operation will normalize
     the input image with: output[channel] = (input[channel] - mean[channel]) / std[channel], where channel >= 1.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Note:
         This operation is executed on the CPU by default, but it is also supported
         to be executed on the GPU or Ascend via heterogeneous acceleration.
@@ -1877,19 +2636,30 @@ class Normalize(ImageTensorOperation):
         ``CPU`` ``GPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> decode_op = vision.Decode() ## Decode output is expected to be HWC format
+        >>> # 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"])
         >>> normalize_op = vision.Normalize(mean=[121.0, 115.0, 100.0], std=[70.0, 68.0, 71.0], is_hwc=True)
-        >>> transforms_list = [decode_op, normalize_op]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[normalize_op],
         ...                                                 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) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.Normalize(mean=[121.0, 115.0, 100.0], std=[70.0, 68.0, 71.0])(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_normalize
@@ -1906,34 +2676,49 @@ class Normalize(ImageTensorOperation):
         """
         Set the device for the current operator execution.
 
+        - When the device is CPU, input type support  `uint8`/`float32`/`float64`, 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`` . Default: ``CPU`` .
+                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not ``CPU`` .
+            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
 
         Supported Platforms:
-            ``CPU``
+            ``CPU`` ``Ascend``
 
         Examples:
+            >>> import numpy as np
             >>> import mindspore.dataset as ds
             >>> import mindspore.dataset.vision as vision
             >>> from mindspore.dataset.vision import Inter
             >>>
-            >>> decode_op = vision.Decode()
+            >>> # 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"])
             >>> resize_op = vision.Resize([100, 75], Inter.BICUBIC)
-            >>> transforms_list = [decode_op, resize_op]
-            >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-            >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-            ...                                                 input_columns=["image"])
+            >>> transforms_list = [resize_op]
+            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
             >>> normalize_op = vision.Normalize(mean=[121.0, 115.0, 100.0], std=[70.0, 68.0, 71.0]).device("Ascend")
-            >>> image_folder_dataset = image_folder_dataset.map(operations=normalize_op, input_columns=["image"])
+            >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=normalize_op, 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, 75, 3) float32
+            >>>
+            >>> # Use the transform in eager mode
+            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+            >>> output = vision.Normalize(mean=[121.0, 115.0, 100.0], std=[70.0, 68.0, 71.0]).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (100, 100, 3) float32
 
         Tutorial Examples:
             - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
         return self
@@ -1952,8 +2737,8 @@ class NormalizePad(ImageTensorOperation):
         std (sequence): List or tuple of standard deviations for each channel, with respect to channel order.
             The standard deviation values must be in range (0.0, 255.0].
         dtype (str, optional): Set the output data type of normalized image. Default: ``"float32"``.
-        is_hwc (bool, optional): Whether the input image is HWC.
-            ``True`` - HWC format, ``False`` - CHW format. Default: ``True``.
+        is_hwc (bool, optional): Specify the format of input image.
+            ``True`` - HW(C) format, ``False`` - CHW format. Default: ``True``.
 
     Raises:
         TypeError: If `mean` is not of type sequence.
@@ -1968,17 +2753,28 @@ class NormalizePad(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> decode_op = vision.Decode()
+        >>> # 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"])
         >>> normalize_pad_op = vision.NormalizePad(mean=[121.0, 115.0, 100.0],
         ...                                        std=[70.0, 68.0, 71.0],
         ...                                        dtype="float32")
-        >>> transforms_list = [decode_op, normalize_pad_op]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [normalize_pad_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, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.NormalizePad(mean=[121.0, 115.0, 100.0], std=[70.0, 68.0, 71.0], dtype="float32")(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 4) float32
     """
 
     @check_normalizepad
@@ -1999,6 +2795,8 @@ class Pad(ImageTensorOperation, PyTensorOperation):
     """
     Pad the image according to padding parameters.
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         padding (Union[int, Sequence[int, int], Sequence[int, int, int, int]]): The number of pixels
             to pad each border of the image.
@@ -2036,17 +2834,29 @@ class Pad(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.Pad([100, 100, 100, 100])]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.Pad([100, 100, 100, 100])]
+        >>> 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
+        (300, 300, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.Pad([100, 100, 100, 100])(data)
+        >>> print(output.shape, output.dtype)
+        (300, 300, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_pad
@@ -2060,8 +2870,55 @@ class Pad(ImageTensorOperation, PyTensorOperation):
         self.random = False
         self.padding_mode = padding_mode
 
+    @check_device_target
+    def device(self, device_target="CPU"):
+        """
+        Set the device for the current operator execution.
+
+        - 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
+                ``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"])
+            >>> pad_op = vision.Pad([100, 100, 100, 100]).device("Ascend")
+            >>> transforms_list = [pad_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
+            (300, 300, 3) uint8
+            >>>
+            >>> # Use the transform in eager mode
+            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+            >>> output = vision.Pad([100, 100, 100, 100]).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (300, 300, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        return self
+
     def parse(self):
-        return cde.PadOperation(self.padding, self.fill_value, Border.to_c_type(self.padding_mode))
+        return cde.PadOperation(self.padding, self.fill_value, Border.to_c_type(self.padding_mode), self.device_target)
 
     def _execute_py(self, img):
         """
@@ -2114,17 +2971,29 @@ class PadToSize(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.PadToSize([256, 256])]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.PadToSize([256, 256])]
+        >>> 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
+        (256, 256, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.PadToSize([256, 256])(data)
+        >>> print(output.shape, output.dtype)
+        (256, 256, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_pad_to_size
@@ -2167,23 +3036,35 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
-        >>> from mindspore.dataset.transforms import Compose
         >>> from mindspore.dataset.vision import Inter
         >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> start_points = [[0, 63], [63, 63], [63, 0], [0, 0]]
         >>> end_points = [[0, 32], [32, 32], [32, 0], [0, 0]]
-        >>> transforms_list = Compose([vision.Decode(),
-        ...                            vision.Perspective(start_points, end_points, Inter.BILINEAR)])
+        >>> transforms_list = [vision.Perspective(start_points, end_points, Inter.BILINEAR)]
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        >>> start_points = [[0, 63], [63, 63], [63, 0], [0, 0]]
+        >>> end_points = [[0, 32], [32, 32], [32, 0], [0, 0]]
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.Perspective(start_points, end_points, Inter.BILINEAR)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_perspective
@@ -2198,10 +3079,63 @@ class Perspective(ImageTensorOperation, PyTensorOperation):
             self.implementation = Implementation.PY
         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 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
+                ``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"])
+            >>> start_points = [[0, 63], [63, 63], [63, 0], [0, 0]]
+            >>> end_points = [[0, 32], [32, 32], [32, 0], [0, 0]]
+            >>> perspective_op = vision.Perspective(start_points, end_points).device("Ascend")
+            >>> transforms_list = [perspective_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
+            >>> start_points = [[0, 63], [63, 63], [63, 0], [0, 0]]
+            >>> end_points = [[0, 32], [32, 32], [32, 0], [0, 0]]
+            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+            >>> output = vision.Perspective(start_points, end_points, Inter.BILINEAR).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (100, 100, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        return self
+
     def parse(self):
         if self.interpolation == Inter.ANTIALIAS:
             raise TypeError("Current Interpolation is not supported with NumPy input.")
-        return cde.PerspectiveOperation(self.start_points, self.end_points, Inter.to_c_type(self.interpolation))
+        return cde.PerspectiveOperation(self.start_points, self.end_points,
+                                        Inter.to_c_type(self.interpolation), self.device_target)
 
     def _execute_py(self, img):
         """
@@ -2232,17 +3166,29 @@ class Posterize(ImageTensorOperation):
         RuntimeError: If shape of the input image is not <H, W> or <H, W, C>.
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.Posterize(4)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.Posterize(4)]
+        >>> 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)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_posterize
@@ -2292,16 +3238,30 @@ class RandAugment(ImageTensorOperation):
         ``CPU``
 
     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"])
+        >>> transforms_list = [vision.RandAugment()]
+        >>> 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
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandAugment()]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list, input_columns=["image"])
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.RandAugment(interpolation=Inter.BILINEAR, fill_value=255)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_rand_augment
@@ -2343,17 +3303,29 @@ class RandomAdjustSharpness(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomAdjustSharpness(2.0, 0.5)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomAdjustSharpness(2.0, 0.5)]
+        >>> 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.RandomAdjustSharpness(2.0, 1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_adjust_sharpness
@@ -2419,23 +3391,35 @@ class RandomAffine(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> decode_op = vision.Decode()
+        >>> # Use the transform in dataset pipeline mode
         >>> random_affine_op = vision.RandomAffine(degrees=15,
         ...                                        translate=(-0.1, 0.1, 0, 0),
         ...                                        scale=(0.9, 1.1),
         ...                                        resample=Inter.NEAREST)
-        >>> transforms_list = [decode_op, random_affine_op]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [random_affine_op]
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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.RandomAffine(degrees=15, translate=(-0.1, 0.1, 0, 0),
+        ...                              scale=(0.9, 1.1), resample=Inter.NEAREST)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_affine
@@ -2532,17 +3516,29 @@ class RandomAutoContrast(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomAutoContrast(cutoff=0.0, ignore=None, prob=0.5)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomAutoContrast(cutoff=0.0, ignore=None, prob=0.5)]
+        >>> 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.RandomAutoContrast(cutoff=0.0, ignore=None, prob=1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_auto_contrast
@@ -2580,17 +3576,29 @@ class RandomColor(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomColor((0.5, 2.0))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomColor((0.5, 2.0))]
+        >>> 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.RandomColor((0.1, 1.9))(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_positive_degrees
@@ -2655,21 +3663,32 @@ class RandomColorAdjust(ImageTensorOperation, PyTensorOperation):
         ``CPU`` ``GPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> decode_op = vision.Decode()
+        >>> # 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"])
         >>> transform_op = vision.RandomColorAdjust(brightness=(0.5, 1),
         ...                                         contrast=(0.4, 1),
         ...                                         saturation=(0.3, 1))
-        >>> transforms_list = [decode_op, transform_op]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [transform_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.RandomColorAdjust(brightness=(0.5, 1), contrast=(0.4, 1), saturation=(0.3, 1))(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_color_adjust
@@ -2766,20 +3785,31 @@ class RandomCrop(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Border
         >>>
-        >>> decode_op = vision.Decode()
-        >>> random_crop_op = vision.RandomCrop(512, [200, 200, 200, 200], padding_mode=Border.EDGE)
-        >>> transforms_list = [decode_op, random_crop_op]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in dataset pipeline mode
+        >>> random_crop_op = vision.RandomCrop(64, [16, 16, 16, 16], padding_mode=Border.EDGE)
+        >>> transforms_list = [random_crop_op]
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (64, 64, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.RandomCrop(8, [10, 10, 10, 10], padding_mode=Border.EDGE)(data)
+        >>> print(output.shape, output.dtype)
+        (8, 8, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_crop
@@ -2852,22 +3882,59 @@ class RandomCropDecodeResize(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import os
+        >>> import numpy as np
+        >>> from PIL import Image, ImageDraw
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> class MyDataset:
+        ...     def __init__(self):
+        ...         self.data = []
+        ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+        ...         draw = ImageDraw.Draw(img)
+        ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+        ...         img.save("./1.jpg")
+        ...         data = np.fromfile("./1.jpg", np.uint8)
+        ...         self.data.append(data)
+        ...
+        ...     def __getitem__(self, index):
+        ...         return self.data[0]
+        ...
+        ...     def __len__(self):
+        ...         return 5
+        >>>
+        >>> my_dataset = MyDataset()
+        >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
         >>> resize_crop_decode_op = vision.RandomCropDecodeResize(size=(50, 75),
         ...                                                       scale=(0.25, 0.5),
         ...                                                       interpolation=Inter.NEAREST,
         ...                                                       max_attempts=5)
         >>> transforms_list = [resize_crop_decode_op]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns=["image"])
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (50, 75, 3) uint8
+        >>> os.remove("./1.jpg")
+        >>>
+        >>> # Use the transform in eager mode
+        >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+        >>> draw = ImageDraw.Draw(img)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+        >>> img.save("./2.jpg")
+        >>> data = np.fromfile("./2.jpg", np.uint8)
+        >>> output = vision.RandomCropDecodeResize(size=(50, 75), scale=(0, 10.0), ratio=(0.5, 0.5),
+        ...                                        interpolation=Inter.BILINEAR, max_attempts=1)(data)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (50, 75, 3) uint8
+        >>> os.remove("./2.jpg")
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_resize_crop
@@ -2948,19 +4015,40 @@ class RandomCropWithBBox(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> decode_op = vision.Decode()
-        >>> random_crop_with_bbox_op = vision.RandomCropWithBBox([512, 512], [200, 200, 200, 200])
-        >>> transforms_list = [decode_op, random_crop_with_bbox_op]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(np.float32))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[func],
+        ...                                                 input_columns=["image"],
+        ...                                                 output_columns=["image", "bbox"])
+        >>> random_crop_with_bbox_op = vision.RandomCropWithBBox([64, 64], [20, 20, 20, 20])
+        >>> transforms_list = [random_crop_with_bbox_op]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (64, 64, 3) float32
+        (1, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(data.dtype))
+        >>> func_data, func_bboxes = func(data)
+        >>> output = vision.RandomCropWithBBox([64, 64], [20, 20, 20, 20])(func_data, func_bboxes)
+        >>> print(output[0].shape, output[0].dtype)
+        (64, 64, 3) float32
+        >>> print(output[1].shape, output[1].dtype)
+        (1, 4) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_crop
@@ -3006,17 +4094,29 @@ class RandomEqualize(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomEqualize(0.5)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomEqualize(0.5)]
+        >>> 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.RandomEqualize(1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_prob
@@ -3069,21 +4169,32 @@ class RandomErasing(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
-        >>> transforms_list = Compose([vision.Decode(to_pil=True),
-        ...                            vision.ToTensor(),
+        >>> # Use the transform in dataset pipeline mode
+        >>> transforms_list = Compose([vision.ToTensor(),
         ...                            vision.RandomErasing(value='random')])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(254, 255, size=(3, 100, 100)).astype(np.uint8)
+        >>> output = vision.RandomErasing(prob=1.0, max_attempts=1)(data)
+        >>> print(output.shape, output.dtype)
+        (3, 100, 100) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_erasing
@@ -3131,21 +4242,57 @@ class RandomGrayscale(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import os
+        >>> import numpy as np
+        >>> from PIL import Image, ImageDraw
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> class MyDataset:
+        ...     def __init__(self):
+        ...         self.data = []
+        ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+        ...         draw = ImageDraw.Draw(img)
+        ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+        ...         img.save("./1.jpg")
+        ...         data = np.fromfile("./1.jpg", np.uint8)
+        ...         self.data.append(data)
+        ...
+        ...     def __getitem__(self, index):
+        ...         return self.data[0]
+        ...
+        ...     def __len__(self):
+        ...         return 5
+        >>>
+        >>> my_dataset = MyDataset()
+        >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
         >>> transforms_list = Compose([vision.Decode(to_pil=True),
         ...                            vision.RandomGrayscale(0.3),
         ...                            vision.ToTensor()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns="image")
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 300, 300) float32
+        >>> os.remove("./1.jpg")
+        >>>
+        >>> # Use the transform in eager mode
+        >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+        >>> draw = ImageDraw.Draw(img)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+        >>> img.save("./2.jpg")
+        >>> data = Image.open("./2.jpg")
+        >>> output = vision.RandomGrayscale(1.0)(data)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (300, 300, 3) uint8
+        >>> os.remove("./2.jpg")
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_prob
@@ -3193,17 +4340,29 @@ class RandomHorizontalFlip(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomHorizontalFlip(0.75)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomHorizontalFlip(0.75)]
+        >>> 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.RandomHorizontalFlip(1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_prob
@@ -3244,17 +4403,40 @@ class RandomHorizontalFlipWithBBox(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomHorizontalFlipWithBBox(0.70)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(np.float32))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[func],
+        ...                                                 input_columns=["image"],
+        ...                                                 output_columns=["image", "bbox"])
+        >>> transforms_list = [vision.RandomHorizontalFlipWithBBox(0.70)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (100, 100, 3) float32
+        (1, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(data.dtype))
+        >>> func_data, func_bboxes = func(data)
+        >>> output = vision.RandomHorizontalFlipWithBBox(1)(func_data, func_bboxes)
+        >>> print(output[0].shape, output[0].dtype)
+        (100, 100, 3) float32
+        >>> print(output[1].shape, output[1].dtype)
+        (1, 4) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_prob
@@ -3284,17 +4466,29 @@ class RandomInvert(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomInvert(0.5)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomInvert(0.5)]
+        >>> 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.RandomInvert(1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_prob
@@ -3324,17 +4518,29 @@ class RandomLighting(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomLighting(0.1)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomLighting(0.1)]
+        >>> 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.RandomLighting(0.1)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_alpha
@@ -3381,21 +4587,57 @@ class RandomPerspective(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import os
+        >>> import numpy as np
+        >>> from PIL import Image, ImageDraw
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> class MyDataset:
+        ...     def __init__(self):
+        ...         self.data = []
+        ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+        ...         draw = ImageDraw.Draw(img)
+        ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+        ...         img.save("./1.jpg")
+        ...         data = np.fromfile("./1.jpg", np.uint8)
+        ...         self.data.append(data)
+        ...
+        ...     def __getitem__(self, index):
+        ...         return self.data[0]
+        ...
+        ...     def __len__(self):
+        ...         return 5
+        >>>
+        >>> my_dataset = MyDataset()
+        >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
         >>> transforms_list = Compose([vision.Decode(to_pil=True),
         ...                            vision.RandomPerspective(prob=0.1),
         ...                            vision.ToTensor()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns="image")
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 300, 300) float32
+        >>> os.remove("./1.jpg")
+        >>>
+        >>> # Use the transform in eager mode
+        >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+        >>> draw = ImageDraw.Draw(img)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+        >>> img.save("./2.jpg")
+        >>> data = Image.open("./2.jpg")
+        >>> output = vision.RandomPerspective(prob=1.0)(data)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (300, 300, 3) uint8
+        >>> os.remove("./2.jpg")
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_perspective
@@ -3448,17 +4690,29 @@ class RandomPosterize(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomPosterize((6, 8))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomPosterize((6, 8))]
+        >>> 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.RandomPosterize(1)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_posterize
@@ -3510,21 +4764,32 @@ class RandomResizedCrop(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> decode_op = vision.Decode()
+        >>> # Use the transform in dataset pipeline mode
         >>> resize_crop_op = vision.RandomResizedCrop(size=(50, 75), scale=(0.25, 0.5),
         ...                                           interpolation=Inter.BILINEAR)
-        >>> transforms_list = [decode_op, resize_crop_op]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [resize_crop_op]
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (50, 75, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.RandomResizedCrop(size=(50, 75), scale=(0.25, 0.5), interpolation=Inter.BILINEAR)(data)
+        >>> print(output.shape, output.dtype)
+        (50, 75, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_resize_crop
@@ -3598,20 +4863,42 @@ class RandomResizedCropWithBBox(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> decode_op = vision.Decode()
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(np.float32))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[func],
+        ...                                                 input_columns=["image"],
+        ...                                                 output_columns=["image", "bbox"])
         >>> bbox_op = vision.RandomResizedCropWithBBox(size=50, interpolation=Inter.NEAREST)
-        >>> transforms_list = [decode_op, bbox_op]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [bbox_op]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (50, 50, 3) float32
+        (1, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(data.dtype))
+        >>> func_data, func_bboxes = func(data)
+        >>> output = vision.RandomResizedCropWithBBox((16, 64), (0.5, 0.5), (0.5, 0.5))(func_data, func_bboxes)
+        >>> print(output[0].shape, output[0].dtype)
+        (16, 64, 3) float32
+        >>> print(output[1].shape, output[1].dtype)
+        (1, 4) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_resize_crop
@@ -3651,22 +4938,38 @@ class RandomResize(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # 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"])
         >>> # 1) randomly resize image, keeping aspect ratio
-        >>> transforms_list1 = [vision.Decode(), vision.RandomResize(50)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list1 = [vision.RandomResize(50)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list1, 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
+        (50, 50, 3) uint8
         >>> # 2) randomly resize image to landscape style
-        >>> transforms_list2 = [vision.Decode(), vision.RandomResize((40, 60))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list2,
-        ...                                                 input_columns=["image"])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> transforms_list2 = [vision.RandomResize((40, 60))]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list2, 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
+        (40, 60, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.RandomResize(10)(data)
+        >>> print(output.shape, output.dtype)
+        (10, 10, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_resize
@@ -3703,24 +5006,55 @@ class RandomResizeWithBBox(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import copy
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(np.float32))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[func],
+        ...                                                 input_columns=["image"],
+        ...                                                 output_columns=["image", "bbox"])
+        >>> numpy_slices_dataset2 = copy.deepcopy(numpy_slices_dataset)
         >>>
         >>> # 1) randomly resize image with bounding boxes, keeping aspect ratio
-        >>> transforms_list1 = [vision.Decode(), vision.RandomResizeWithBBox(60)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list1 = [vision.RandomResizeWithBBox(60)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list1,
+        ...                                                 input_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (60, 60, 3) float32
+        (1, 4) float32
         >>>
         >>> # 2) randomly resize image with bounding boxes to portrait style
-        >>> transforms_list2 = [vision.Decode(), vision.RandomResizeWithBBox((80, 60))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list2,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list2 = [vision.RandomResizeWithBBox((80, 60))]
+        >>> numpy_slices_dataset2 = numpy_slices_dataset2.map(operations=transforms_list2,
+        ...                                                   input_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset2.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (80, 60, 3) float32
+        (1, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(data.dtype))
+        >>> func_data, func_bboxes = func(data)
+        >>> output = vision.RandomResizeWithBBox(64)(func_data, func_bboxes)
+        >>> print(output[0].shape, output[0].dtype)
+        (64, 64, 3) float32
+        >>> print(output[1].shape, output[1].dtype)
+        (1, 4) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_resize
@@ -3770,21 +5104,33 @@ class RandomRotation(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> transforms_list = [vision.Decode(),
-        ...                    vision.RandomRotation(degrees=5.0,
-        ...                    resample=Inter.NEAREST,
-        ...                    expand=True)]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in dataset pipeline mode
+        >>> seed = ds.config.get_seed()
+        >>> ds.config.set_seed(12345)
+        >>> transforms_list = [vision.RandomRotation(degrees=5.0, resample=Inter.NEAREST, expand=True)]
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (107, 107, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.RandomRotation(degrees=90, resample=Inter.NEAREST, expand=True)(data)
+        >>> print(output.shape, output.dtype)
+        (119, 119, 3) uint8
+        >>> ds.config.set_seed(seed)
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_rotation
@@ -3855,21 +5201,35 @@ class RandomSelectSubpolicy(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
+        >>> # 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"])
         >>> policy = [[(vision.RandomRotation((45, 45)), 0.5),
         ...            (vision.RandomVerticalFlip(), 1),
         ...            (vision.RandomColorAdjust(), 0.8)],
         ...           [(vision.RandomRotation((90, 90)), 1),
         ...            (vision.RandomColorAdjust(), 0.2)]]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=vision.RandomSelectSubpolicy(policy),
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=vision.RandomSelectSubpolicy(policy),
         ...                                                 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)
+        >>> policy = [[(vision.RandomRotation((90, 90)), 1), (vision.RandomColorAdjust(), 1)]]
+        >>> output = vision.RandomSelectSubpolicy(policy)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_select_subpolicy_op
@@ -3910,17 +5270,29 @@ class RandomSharpness(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomSharpness(degrees=(0.2, 1.9))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomSharpness(degrees=(0.2, 1.9))]
+        >>> 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.RandomSharpness(degrees=(0, 0.6))(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_positive_degrees
@@ -3953,8 +5325,9 @@ class RandomSolarize(ImageTensorOperation):
     Args:
         threshold (tuple, optional): Range of random solarize threshold. Default: ``(0, 255)``.
             Threshold values should always be in (min, max) format,
-            where min and max are integers in the range [0, 255], and min <= max.
-            If min=max, then invert all pixel values above min(max).
+            where min and max are integers in the range [0, 255], and min <= max. The pixel values
+            belonging to the [min, max] range will be inverted.
+            If min=max, then invert all pixel values greater than or equal min(max).
 
     Raises:
         TypeError : If `threshold` is not of type tuple.
@@ -3964,17 +5337,29 @@ class RandomSolarize(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomSolarize(threshold=(10,100))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomSolarize(threshold=(10,100))]
+        >>> 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.RandomSolarize(threshold=(1, 10))(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_random_solarize
@@ -4004,17 +5389,29 @@ class RandomVerticalFlip(ImageTensorOperation, PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomVerticalFlip(0.25)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.RandomVerticalFlip(0.25)]
+        >>> 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.array([[0, 1, 2, 3, 4, 5]], dtype=np.uint8).reshape((2, 3))
+        >>> output = vision.RandomVerticalFlip(1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (2, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_prob
@@ -4055,17 +5452,39 @@ class RandomVerticalFlipWithBBox(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.RandomVerticalFlipWithBBox(0.20)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(np.float32))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[func],
+        ...                                                 input_columns=["image"],
+        ...                                                 output_columns=["image", "bbox"])
+        >>> transforms_list = [vision.RandomVerticalFlipWithBBox(0.20)]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (100, 100, 3) float32
+        (1, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(data.dtype))
+        >>> func_data, func_bboxes = func(data)
+        >>> output = vision.RandomVerticalFlipWithBBox(1)(func_data, func_bboxes)
+        >>> print(output[0].shape, output[0].dtype)
+        (100, 100, 3) float32
+        >>> print(output[1].shape, output[1].dtype)
+        (1, 4) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_prob
@@ -4099,17 +5518,29 @@ class Rescale(ImageTensorOperation):
         ``CPU`` ``GPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.Rescale(1.0 / 255.0, -1.0)]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.Rescale(1.0 / 255.0, -1.0)]
+        >>> 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) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.Rescale(1.0 / 255.0, -1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_rescale
@@ -4127,6 +5558,8 @@ class Resize(ImageTensorOperation, PyTensorOperation):
     """
     Resize the input image to the given size with a given interpolation mode :class:`~.vision.Inter` .
 
+    Supports Ascend hardware acceleration and can be enabled through the `.device("Ascend")` method.
+
     Args:
         size (Union[int, Sequence[int]]): The output size of the resized image. The size value(s) must be positive.
             If size is an integer, the smaller edge of the image will be resized to this value with
@@ -4145,20 +5578,31 @@ class Resize(ImageTensorOperation, PyTensorOperation):
         ``CPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> decode_op = vision.Decode()
+        >>> # 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"])
         >>> resize_op = vision.Resize([100, 75], Inter.BICUBIC)
-        >>> transforms_list = [decode_op, resize_op]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [resize_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, 75, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.Resize([5, 5], Inter.BICUBIC)(data)
+        >>> print(output.shape, output.dtype)
+        (5, 5, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_resize_interpolation
@@ -4180,32 +5624,45 @@ class Resize(ImageTensorOperation, PyTensorOperation):
         """
         Set the device for the current operator execution.
 
+        - 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
-                ``CPU`` . Default: ``CPU`` .
+                ``CPU`` and ``Ascend`` . Default: ``CPU`` .
 
         Raises:
             TypeError: If `device_target` is not of type str.
-            ValueError: If `device_target` is not ``CPU`` .
+            ValueError: If `device_target` is not within the valid set of ['CPU', 'Ascend'].
 
         Supported Platforms:
-            ``CPU``
+            ``CPU`` ``Ascend``
 
         Examples:
+            >>> import numpy as np
             >>> import mindspore.dataset as ds
             >>> import mindspore.dataset.vision as vision
             >>> from mindspore.dataset.vision import Inter
             >>>
-            >>> decode_op = vision.Decode()
+            >>> # Use the transform in dataset pipeline mode
             >>> resize_op = vision.Resize([100, 75], Inter.BICUBIC).device("Ascend")
-            >>> transforms_list = [decode_op, resize_op]
-            >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-            >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-            ...                                                 input_columns=["image"])
+            >>> transforms_list = [resize_op]
+            >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+            >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+            >>> 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, 75, 3) uint8
+            >>>
+            >>> # Use the transform in eager mode
+            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+            >>> output = vision.Resize([25, 25], Inter.BICUBIC).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (25, 25, 3) uint8
 
         Tutorial Examples:
             - `Illustration of vision transforms
-              <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
         """
         self.device_target = device_target
         if self.interpolation == Inter.ANTIALIAS and self.device_target == "Ascend":
@@ -4267,18 +5724,30 @@ class ResizedCrop(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> transforms_list = [vision.Decode(), vision.ResizedCrop(0, 0, 128, 128, (100, 75), Inter.BILINEAR)]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in dataset pipeline mode
+        >>> transforms_list = [vision.ResizedCrop(0, 0, 64, 64, (100, 75), Inter.BILINEAR)]
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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, 75, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.ResizedCrop(0, 0, 1, 1, (5, 5), Inter.BILINEAR)(data)
+        >>> print(output.shape, output.dtype)
+        (5, 5, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_resized_crop
@@ -4295,9 +5764,57 @@ class ResizedCrop(ImageTensorOperation):
         self.interpolation = interpolation
         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/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
+                ``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"])
+            >>> resize_crop_op = vision.ResizedCrop(0, 0, 64, 64, (100, 75)).device("Ascend")
+            >>> transforms_list = [resize_crop_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, 75, 3) uint8
+            >>>
+            >>> # Use the transform in eager mode
+            >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+            >>> output = vision.ResizedCrop(0, 0, 64, 64, (32, 16), Inter.BILINEAR).device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (32, 16, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        return self
+
     def parse(self):
         return cde.ResizedCropOperation(self.top, self.left, self.height,
-                                        self.width, self.size, Inter.to_c_type(self.interpolation))
+                                        self.width, self.size, Inter.to_c_type(self.interpolation), self.device_target)
 
 
 class ResizeWithBBox(ImageTensorOperation):
@@ -4322,20 +5839,41 @@ class ResizeWithBBox(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> decode_op = vision.Decode()
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(np.float32))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=[func],
+        ...                                                 input_columns=["image"],
+        ...                                                 output_columns=["image", "bbox"])
         >>> bbox_op = vision.ResizeWithBBox(50, Inter.NEAREST)
-        >>> transforms_list = [decode_op, bbox_op]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> transforms_list = [bbox_op]
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image", "bbox"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     print(item["bbox"].shape, item["bbox"].dtype)
+        ...     break
+        (50, 50, 3) float32
+        (1, 4) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.float32)
+        >>> func = lambda img: (data, np.array([[0, 0, data.shape[1], data.shape[0]]]).astype(data.dtype))
+        >>> func_data, func_bboxes = func(data)
+        >>> output = vision.ResizeWithBBox(100)(func_data, func_bboxes)
+        >>> print(output[0].shape, output[0].dtype)
+        (100, 100, 3) float32
+        >>> print(output[1].shape, output[1].dtype)
+        (1, 4) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_resize_interpolation
@@ -4367,22 +5905,33 @@ class RgbToHsv(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
-        >>> transforms_list = Compose([vision.Decode(to_pil=True),
-        ...                            vision.CenterCrop(20),
+        >>> # Use the transform in dataset pipeline mode
+        >>> transforms_list = Compose([vision.CenterCrop(20),
         ...                            vision.ToTensor(),
         ...                            vision.RgbToHsv()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (3, 20, 20) float64
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.RgbToHsv(is_hwc=True)(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) float64
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_rgb_to_hsv
@@ -4437,21 +5986,30 @@ class Rotate(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> transforms_list = [vision.Decode(),
-        ...                    vision.Rotate(degrees=30.0,
-        ...                    resample=Inter.NEAREST,
-        ...                    expand=True)]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # Use the transform in dataset pipeline mode
+        >>> transforms_list = [vision.Rotate(degrees=30.0, resample=Inter.NEAREST, expand=True)]
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> 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
+        (137, 137, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.Rotate(degrees=30.0, resample=Inter.NEAREST, expand=True)(data)
+        >>> print(output.shape, output.dtype)
+        (137, 137, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_rotate
@@ -4476,12 +6034,12 @@ class Rotate(ImageTensorOperation):
 
 
 class SlicePatches(ImageTensorOperation):
-    """
+    r"""
     Slice Tensor to multiple patches in horizontal and vertical directions.
 
     The usage scenario is suitable to large height and width Tensor. The Tensor
     will keep the same if set both num_height and num_width to 1. And the
-    number of output tensors is equal to num_height*num_width.
+    number of output tensors is equal to :math:`num\_height * num\_width`.
 
     Args:
         num_height (int, optional): The number of patches in vertical direction, which must be positive. Default: ``1``.
@@ -4507,24 +6065,36 @@ class SlicePatches(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # default padding mode
-        >>> decode_op = vision.Decode()
         >>> num_h, num_w = (1, 4)
         >>> slice_patches_op = vision.SlicePatches(num_h, num_w)
-        >>> transforms_list = [decode_op, slice_patches_op]
+        >>> transforms_list = [slice_patches_op]
         >>> cols = ['img' + str(x) for x in range(num_h*num_w)]
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list,
         ...                                                 input_columns=["image"],
         ...                                                 output_columns=cols)
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(len(item), item["img0"].shape, item["img0"].dtype)
+        ...     break
+        4 (100, 25, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.SlicePatches(1, 2)(data)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (2, 100, 50, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_slice_patches
@@ -4548,7 +6118,8 @@ class Solarize(ImageTensorOperation):
     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.
-            If a single value is provided or min=max, then invert all pixel values above min(max).
+            The pixel values belonging to the [min, max] range will be inverted.
+            If a single value is provided or min=max, then invert all pixel values greater than or equal min(max).
 
     Raises:
         TypeError: If `threshold` is not of type float or Sequence[float, float].
@@ -4558,17 +6129,29 @@ class Solarize(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.Solarize(threshold=(10, 100))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.Solarize(threshold=(10, 100))]
+        >>> 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=(1, 10))(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_solarize
@@ -4603,23 +6186,58 @@ class TenCrop(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import os
+        >>> import numpy as np
+        >>> from PIL import Image, ImageDraw
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
-        >>> import numpy
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> class MyDataset:
+        ...     def __init__(self):
+        ...         self.data = []
+        ...         img = Image.new("RGB", (300, 300), (255, 255, 255))
+        ...         draw = ImageDraw.Draw(img)
+        ...         draw.ellipse(((0, 0), (100, 100)), fill=(255, 0, 0), outline=(255, 0, 0), width=5)
+        ...         img.save("./1.jpg")
+        ...         data = np.fromfile("./1.jpg", np.uint8)
+        ...         self.data.append(data)
+        ...
+        ...     def __getitem__(self, index):
+        ...         return self.data[0]
+        ...
+        ...     def __len__(self):
+        ...         return 5
+        >>>
+        >>> my_dataset = MyDataset()
+        >>> generator_dataset = ds.GeneratorDataset(my_dataset, column_names="image")
         >>> transforms_list = Compose([vision.Decode(to_pil=True),
         ...                            vision.TenCrop(size=200),
         ...                            # 4D stack of 10 images
-        ...                            lambda *images: numpy.stack([vision.ToTensor()(image) for image in images])])
+        ...                            lambda *images: np.stack([vision.ToTensor()(image) for image in images])])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> generator_dataset = generator_dataset.map(operations=transforms_list, input_columns="image")
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (10, 3, 200, 200) float32
+        >>> os.remove("./1.jpg")
+        >>>
+        >>> # Use the transform in eager mode
+        >>> img = Image.new("RGB", (300, 300), (255, 255, 255))
+        >>> draw = ImageDraw.Draw(img)
+        >>> draw.polygon([(50, 50), (150, 50), (100, 150)], fill=(0, 255, 0), outline=(0, 255, 0))
+        >>> img.save("./2.jpg")
+        >>> data = Image.open("./2.jpg")
+        >>> output = vision.TenCrop(size=200)(data)
+        >>> print(len(output), np.array(output[0]).shape, np.array(output[0]).dtype)
+        10 (200, 200, 3) uint8
+        >>> os.remove("./2.jpg")
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_ten_crop
@@ -4654,23 +6272,34 @@ class ToNumpy(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # 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"])
         >>> # Use ToNumpy to explicitly select C++ implementation of subsequent op
-        >>> transforms_list = Compose([vision.Decode(True),
-        ...                            vision.RandomHorizontalFlip(0.5),
+        >>> transforms_list = Compose([vision.RandomHorizontalFlip(0.5),
         ...                            vision.ToNumpy(),
-        ...                            vision.Resize((100, 120))])
+        ...                            vision.Resize((50, 60))])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> 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
+        (50, 60, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = list(np.random.randint(0, 255, size=(32, 32, 3, 3)).astype(np.int32))
+        >>> output = vision.ToNumpy()(data)
+        >>> print(type(output), output.shape, output.dtype)
+        <class 'numpy.ndarray'> (32, 32, 3, 3) int32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     def __init__(self):
@@ -4703,22 +6332,34 @@ class ToPIL(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # 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"])
         >>> # data is already decoded, but not in PIL Image format
         >>> transforms_list = Compose([vision.ToPIL(),
         ...                            vision.RandomHorizontalFlip(0.5),
         ...                            vision.ToTensor()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> 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
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.ToPIL()(data)
+        >>> print(type(output), np.array(output).shape, np.array(output).dtype)
+        <class 'PIL.Image.Image'> (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     def __init__(self):
@@ -4756,22 +6397,33 @@ class ToTensor(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # 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"])
         >>> # create a list of transformations to be applied to the "image" column of each data row
-        >>> transforms_list = Compose([vision.Decode(to_pil=True),
-        ...                            vision.RandomHorizontalFlip(0.5),
+        >>> transforms_list = Compose([vision.RandomHorizontalFlip(0.5),
         ...                            vision.ToTensor()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> 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
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> output = vision.ToTensor()(data)
+        >>> print(output.shape, output.dtype)
+        (3, 100, 100) float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_to_tensor
@@ -4810,23 +6462,34 @@ class ToType(TypeCast):
         ``CPU`` ``GPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> import numpy as np
         >>> from mindspore.dataset.transforms import Compose
         >>>
-        >>> transforms_list = Compose([vision.Decode(to_pil=True),
-        ...                            vision.RandomHorizontalFlip(0.5),
+        >>> # 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 = Compose([vision.RandomHorizontalFlip(0.5),
         ...                            vision.ToTensor(),
         ...                            vision.ToType(np.float32)])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> 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
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([2.71606445312564e-03, 6.3476562564e-03]).astype(np.float64)
+        >>> output = vision.ToType(np.float32)(data)
+        >>> print(output, output.dtype)
+        [0.00271606 0.00634766] float32
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
 
@@ -4861,20 +6524,32 @@ class TrivialAugmentWide(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.vision import Inter
         >>>
-        >>> transforms_list = [vision.Decode(), vision.TrivialAugmentWide(num_magnitude_bins=31,
-        ...                                                               interpolation=Inter.NEAREST,
-        ...                                                               fill_value=0)]
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.TrivialAugmentWide(num_magnitude_bins=31,
+        ...                                              interpolation=Inter.NEAREST,
+        ...                                              fill_value=0)]
+        >>> 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.TrivialAugmentWide()(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_trivial_augment_wide
@@ -4915,25 +6590,41 @@ class UniformAugment(CompoundOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
-        >>> transforms = [vision.CenterCrop(64),
-        ...               vision.RandomColor(),
-        ...               vision.RandomSharpness(),
-        ...               vision.RandomRotation(30)]
-        >>> transforms_list = Compose([vision.Decode(to_pil=True),
-        ...                            vision.UniformAugment(transforms),
+        >>> # Use the transform in dataset pipeline mode
+        >>> seed = ds.config.get_seed()
+        >>> ds.config.set_seed(12345)
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> transform = [vision.CenterCrop(64),
+        ...              vision.RandomColor(),
+        ...              vision.RandomSharpness(),
+        ...              vision.RandomRotation(30)]
+        >>> transforms_list = Compose([vision.UniformAugment(transform),
         ...                            vision.ToTensor()])
         >>> # apply the transform to dataset through map function
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns="image")
+        >>> 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
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> transform = [vision.RandomCrop(size=[20, 40], padding=[32, 32, 32, 32]),
+        ...              vision.RandomCrop(size=[20, 40], padding=[32, 32, 32, 32])]
+        >>> output = vision.UniformAugment(transform)(data)
+        >>> print(output.shape, output.dtype)
+        (20, 40, 3) uint8
+        >>> ds.config.set_seed(seed)
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     @check_uniform_augment
@@ -4970,25 +6661,84 @@ class VerticalFlip(ImageTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.vision as vision
         >>>
-        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
-        >>> transforms_list = [vision.Decode(), vision.VerticalFlip()]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
-        ...                                                 input_columns=["image"])
+        >>> # 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.VerticalFlip()]
+        >>> 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.VerticalFlip()(data)
+        >>> print(output.shape, output.dtype)
+        (100, 100, 3) uint8
 
     Tutorial Examples:
         - `Illustration of vision transforms
-          <https://www.mindspore.cn/docs/en/r2.2/api_python/samples/dataset/vision_gallery.html>`_
+          <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
     """
 
     def __init__(self):
         super().__init__()
         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 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
+            >>>
+            >>> # 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"])
+            >>> vertical_flip_op = vision.VerticalFlip().device("Ascend")
+            >>> transforms_list = [vertical_flip_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.VerticalFlip().device("Ascend")(data)
+            >>> print(output.shape, output.dtype)
+            (100, 100, 3) uint8
+
+        Tutorial Examples:
+            - `Illustration of vision transforms
+              <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/samples/dataset/vision_gallery.html>`_
+        """
+        self.device_target = device_target
+        return self
+
     def parse(self):
-        return cde.VerticalFlipOperation()
+        return cde.VerticalFlipOperation(self.device_target)
 
 
 def not_random(func):