!9999 MindCon bug fix ShanDong No1

From: @ming__blue
Reviewed-by: 
Signed-off-by:

mindspore/dataset/core/config.py

@@ -81,8 +81,6 @@ def set_seed(seed):
         ValueError: If seed is invalid (< 0 or > MAX_UINT_32).
 
     Examples:
-        >>> import mindspore.dataset as ds
-        >>>
         >>> # Set a new global configuration value for the seed value.
         >>> # Operations with randomness will use the seed value to generate random values.
         >>> ds.config.set_seed(1000)
@@ -116,8 +114,6 @@ def set_prefetch_size(size):
         ValueError: If prefetch_size is invalid (<= 0 or > MAX_INT_32).
 
     Examples:
-        >>> import mindspore.dataset as ds
-        >>>
         >>> # Set a new global configuration value for the prefetch size.
         >>> ds.config.set_prefetch_size(1000)
     """
@@ -147,8 +143,6 @@ def set_num_parallel_workers(num):
         ValueError: If num_parallel_workers is invalid (<= 0 or > MAX_INT_32).
 
     Examples:
-        >>> import mindspore.dataset as ds
-        >>>
         >>> # Set a new global configuration value for the number of parallel workers.
         >>> # Now parallel dataset operators will run with 8 workers.
         >>> ds.config.set_num_parallel_workers(8)
@@ -180,8 +174,6 @@ def set_monitor_sampling_interval(interval):
         ValueError: If interval is invalid (<= 0 or > MAX_INT_32).
 
     Examples:
-        >>> import mindspore.dataset as ds
-        >>>
         >>> # Set a new global configuration value for the monitor sampling interval.
         >>> ds.config.set_monitor_sampling_interval(100)
     """
@@ -217,8 +209,6 @@ def set_auto_num_workers(enable):
         TypeError: If enable is not of boolean type.
 
     Examples:
-        >>> import mindspore.dataset as ds
-        >>>
         >>> # Enable auto_num_worker feature, this might override the num_parallel_workers passed in by user
         >>> ds.config.set_auto_num_workers(True)
     """
@@ -257,7 +247,7 @@ def get_auto_num_workers():
     Returns:
         Bool, whether auto num worker feature is turned on
     Examples:
-        >>> ds.config.get_auto_num_workers()
+        >>> num_workers = ds.config.get_auto_num_workers()
     """
     return _config.get_auto_num_workers()
 
@@ -274,8 +264,6 @@ def set_callback_timeout(timeout):
         ValueError: If timeout is invalid (<= 0 or > MAX_INT_32).
 
     Examples:
-        >>> import mindspore.dataset as ds
-        >>>
         >>> # Set a new global configuration value for the timeout value.
         >>> ds.config.set_callback_timeout(100)
     """
@@ -316,10 +304,8 @@ def load(file):
         RuntimeError: If file is invalid and parsing fails.
 
     Examples:
-        >>> import mindspore.dataset as ds
-        >>>
         >>> # Set new default configuration values according to values in the configuration file.
-        >>> ds.config.load("path/to/config/file")
+        >>> ds.config.load("/path/to/config_directory/config.cfg")
         >>> # example config file:
         >>> # {
         >>> #     "logFilePath": "/tmp",

mindspore/dataset/vision/c_transforms.py

@@ -23,25 +23,24 @@ to improve their training models.
     class attributes (self.xxx) to support save() and load().
 
 Examples:
-    >>> import mindspore.dataset as ds
-    >>> import mindspore.dataset.transforms.c_transforms as c_transforms
-    >>> import mindspore.dataset.vision.c_transforms as c_vision
     >>> from mindspore.dataset.vision import Border, Inter
-    >>>
-    >>> dataset_dir = "path/to/imagefolder_directory"
+    >>> image_folder_dataset_dir = "/path/to/image_folder_dataset_directory"
     >>> # create a dataset that reads all files in dataset_dir with 8 threads
-    >>> data1 = ds.ImageFolderDataset(dataset_dir, num_parallel_workers=8)
+    >>> image_folder_dataset = ds.ImageFolderDataset(image_folder_dataset_dir,
+    ...                                              num_parallel_workers=8)
     >>> # create a list of transformations to be applied to the image data
     >>> transforms_list = [c_vision.Decode(),
-    >>>                    c_vision.Resize((256, 256), interpolation=Inter.LINEAR),
-    >>>                    c_vision.RandomCrop(200, padding_mode=Border.EDGE),
-    >>>                    c_vision.RandomRotation((0, 15)),
-    >>>                    c_vision.Normalize((100, 115.0, 121.0), (71.0, 68.0, 70.0)),
-    >>>                    c_vision.HWC2CHW()]
+    ...                    c_vision.Resize((256, 256), interpolation=Inter.LINEAR),
+    ...                    c_vision.RandomCrop(200, padding_mode=Border.EDGE),
+    ...                    c_vision.RandomRotation((0, 15)),
+    ...                    c_vision.Normalize((100, 115.0, 121.0), (71.0, 68.0, 70.0)),
+    ...                    c_vision.HWC2CHW()]
     >>> onehot_op = c_transforms.OneHot(num_classes=10)
     >>> # apply the transformation to the dataset through data1.map()
-    >>> data1 = data1.map(operations=transforms_list, input_columns="image")
-    >>> data1 = data1.map(operations=onehot_op, input_columns="label")
+    >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+    ...                                                 input_columns="image")
+    >>> image_folder_dataset = image_folder_dataset.map(operations=onehot_op,
+    ...                                                 input_columns="label")
 """
 import numbers
 import numpy as np
@@ -91,10 +90,9 @@ class AutoContrast(cde.AutoContrastOp):
         ignore (Union[int, sequence], optional): Pixel values to ignore (default=None).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.AutoContrast(cutoff=10.0, ignore=[10, 20])]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_auto_contrast
@@ -121,10 +119,9 @@ class RandomSharpness(cde.RandomSharpnessOp):
         ValueError: If degrees is in (max, min) format instead of (min, max).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomSharpness(degrees=(0.2, 1.9))]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_positive_degrees
@@ -138,10 +135,9 @@ class Equalize(cde.EqualizeOp):
     Apply histogram equalization on input image.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.Equalize()]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
 
@@ -150,10 +146,9 @@ class Invert(cde.InvertOp):
     Apply invert on input image in RGB mode.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.Invert()]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
 
@@ -166,10 +161,9 @@ class Decode(cde.DecodeOp):
             If True means format of decoded image is RGB else BGR(deprecated).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomHorizontalFlip()]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     def __init__(self, rgb=True):
@@ -205,15 +199,14 @@ class CutMixBatch(cde.CutMixBatchOp):
         prob (float, optional): The probability by which CutMix is applied to each image (default = 1.0).
 
     Examples:
-        >>> import mindspore.dataset.transforms.c_transforms as c_transforms
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import ImageBatchFormat
-        >>>
+        >>> from mindspore.dataset.vision import ImageBatchFormat
         >>> onehot_op = c_transforms.OneHot(num_classes=10)
-        >>> data1 = data1.map(operations=onehot_op, input_columns=["label"])
+        >>> image_folder_dataset= image_folder_dataset.map(operations=onehot_op,
+        ...                                                input_columns=["label"])
         >>> cutmix_batch_op = c_vision.CutMixBatch(ImageBatchFormat.NHWC, 1.0, 0.5)
-        >>> data1 = data1.batch(5)
-        >>> data1 = data1.map(operations=cutmix_batch_op, input_columns=["image", "label"])
+        >>> image_folder_dataset = image_folder_dataset.batch(5)
+        >>> image_folder_dataset = image_folder_dataset.map(operations=cutmix_batch_op,
+        ...                                                 input_columns=["image", "label"])
     """
 
     @check_cut_mix_batch_c
@@ -233,10 +226,9 @@ class CutOut(cde.CutOutOp):
         num_patches (int, optional): Number of patches to be cut out of an image (default=1).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.CutOut(80, num_patches=10)]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_cutout
@@ -258,14 +250,13 @@ class MixUpBatch(cde.MixUpBatchOp):
         alpha (float, optional): Hyperparameter of beta distribution (default = 1.0).
 
     Examples:
-        >>> import mindspore.dataset.transforms.c_transforms as c_transforms
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> onehot_op = c_transforms.OneHot(num_classes=10)
-        >>> data1 = data1.map(operations=onehot_op, input_columns=["label"])
+        >>> image_folder_dataset= image_folder_dataset.map(operations=onehot_op,
+        ...                                                input_columns=["label"])
         >>> mixup_batch_op = c_vision.MixUpBatch(alpha=0.9)
-        >>> data1 = data1.batch(5)
-        >>> data1 = data1.map(operations=mixup_batch_op, input_columns=["image", "label"])
+        >>> image_folder_dataset = image_folder_dataset.batch(5)
+        >>> image_folder_dataset = image_folder_dataset.map(operations=mixup_batch_op,
+        ...                                                 input_columns=["image", "label"])
     """
 
     @check_mix_up_batch_c
@@ -285,12 +276,11 @@ class Normalize(cde.NormalizeOp):
             The standard deviation values must be in range (0.0, 255.0].
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> decode_op = c_vision.Decode()
         >>> normalize_op = c_vision.Normalize(mean=[121.0, 115.0, 100.0], std=[70.0, 68.0, 71.0])
         >>> transforms_list = [decode_op, normalize_op]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_normalize_c
@@ -332,12 +322,13 @@ class NormalizePad(cde.NormalizePadOp):
         dtype (str): Set the output data type of normalized image (default is "float32").
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> decode_op = c_vision.Decode()
-        >>> normalize_op = c_vision.NormalizePad(mean=[121.0, 115.0, 100.0], std=[70.0, 68.0, 71.0], dtype="float32")
+        >>> normalize_pad_op = c_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]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_normalizepad_c
@@ -417,14 +408,15 @@ class RandomAffine(cde.RandomAffineOp):
         TypeError: If fill_value is not a single integer or a 3-tuple.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Inter
-        >>>
+        >>> from mindspore.dataset.vision import Inter
         >>> decode_op = c_vision.Decode()
-        >>> random_affine_op = c_vision.RandomAffine(degrees=15, translate=(-0.1, 0.1, 0, 0), scale=(0.9, 1.1),
-        >>>     resample=Inter.NEAREST)
+        >>> random_affine_op = c_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]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_affine
@@ -502,12 +494,12 @@ class RandomCrop(cde.RandomCropOp):
               value of edge.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
+        >>> from mindspore.dataset.vision import Border
         >>> decode_op = c_vision.Decode()
         >>> random_crop_op = c_vision.RandomCrop(512, [200, 200, 200, 200], padding_mode=Border.EDGE)
         >>> transforms_list = [decode_op, random_crop_op]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_crop
@@ -564,12 +556,11 @@ class RandomCropWithBBox(cde.RandomCropWithBBoxOp):
               value of edge.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> decode_op = c_vision.Decode()
         >>> random_crop_with_bbox_op = c_vision.RandomCrop([512, 512], [200, 200, 200, 200])
         >>> transforms_list = [decode_op, random_crop_with_bbox_op]
-        >>> data3 = data3.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_crop
@@ -602,10 +593,9 @@ class RandomHorizontalFlip(cde.RandomHorizontalFlipOp):
         prob (float, optional): Probability of the image being flipped (default=0.5).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomHorizontalFlip(0.75)]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_prob
@@ -622,10 +612,9 @@ class RandomHorizontalFlipWithBBox(cde.RandomHorizontalFlipWithBBoxOp):
         prob (float, optional): Probability of the image being flipped (default=0.5).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomHorizontalFlipWithBBox(0.70)]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_prob
@@ -646,10 +635,9 @@ class RandomPosterize(cde.RandomPosterizeOp):
             magnitude operation (default=(8, 8)).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomPosterize((6, 8))]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_posterize
@@ -668,10 +656,9 @@ class RandomVerticalFlip(cde.RandomVerticalFlipOp):
         prob (float, optional): Probability of the image being flipped (default=0.5).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomVerticalFlip(0.25)]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_prob
@@ -688,10 +675,9 @@ class RandomVerticalFlipWithBBox(cde.RandomVerticalFlipWithBBoxOp):
         prob (float, optional): Probability of the image being flipped (default=0.5).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomVerticalFlipWithBBox(0.20)]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_prob
@@ -711,15 +697,13 @@ class BoundingBoxAugment(cde.BoundingBoxAugmentOp):
             Range: [0, 1] (default=0.3).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> # set bounding box operation with ratio of 1 to apply rotation on all bounding boxes
         >>> bbox_aug_op = c_vision.BoundingBoxAugment(c_vision.RandomRotation(90), 1)
         >>> # map to apply ops
-        >>> data3 = data3.map(operations=[bbox_aug_op],
-        >>>                   input_columns=["image", "bbox"],
-        >>>                   output_columns=["image", "bbox"],
-        >>>                   column_order=["image", "bbox"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=[bbox_aug_op],
+        ...                                                 input_columns=["image", "bbox"],
+        ...                                                 output_columns=["image", "bbox"],
+        ...                                                 column_order=["image", "bbox"])
     """
 
     @check_bounding_box_augment_cpp
@@ -748,13 +732,12 @@ class Resize(cde.ResizeOp):
             - Inter.BICUBIC, means interpolation method is bicubic interpolation.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Inter
-        >>>
+        >>> from mindspore.dataset.vision import Inter
         >>> decode_op = c_vision.Decode()
         >>> resize_op = c_vision.Resize([100, 75], Inter.BICUBIC)
         >>> transforms_list = [decode_op, resize_op]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_resize_interpolation
@@ -802,13 +785,12 @@ class ResizeWithBBox(cde.ResizeWithBBoxOp):
             - Inter.BICUBIC, means interpolation method is bicubic interpolation.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Inter
-        >>>
+        >>> from mindspore.dataset.vision import Inter
         >>> decode_op = c_vision.Decode()
         >>> bbox_op = c_vision.ResizeWithBBox(50, Inter.NEAREST)
         >>> transforms_list = [decode_op, bbox_op]
-        >>> data3 = data3.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_resize_interpolation
@@ -846,13 +828,12 @@ class RandomResizedCropWithBBox(cde.RandomCropAndResizeWithBBoxOp):
             crop area (default=10). If exceeded, fall back to use center crop instead.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Inter
-        >>>
+        >>> from mindspore.dataset.vision import Inter
         >>> decode_op = c_vision.Decode()
         >>> bbox_op = c_vision.RandomResizedCropWithBBox(size=50, interpolation=Inter.NEAREST)
         >>> transforms_list = [decode_op, bbox_op]
-        >>> data3 = data3.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_resize_crop
@@ -894,14 +875,13 @@ class RandomResizedCrop(cde.RandomCropAndResizeOp):
             crop_area (default=10). If exceeded, fall back to use center_crop instead.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Inter
-        >>>
+        >>> from mindspore.dataset.vision import Inter
         >>> decode_op = c_vision.Decode()
         >>> resize_crop_op = c_vision.RandomResizedCrop(size=(50, 75), scale=(0.25, 0.5),
-        >>>     interpolation=Inter.BILINEAR)
+        ...                                             interpolation=Inter.BILINEAR)
         >>> transforms_list = [decode_op, resize_crop_op]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_resize_crop
@@ -928,14 +908,14 @@ class CenterCrop(cde.CenterCropOp):
             If size is a sequence of length 2, it should be (height, width).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> # crop image to a square
         >>> transforms_list1 = [c_vision.Decode(), c_vision.CenterCrop(50)]
-        >>> data1 = data1.map(operations=transforms_list1, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
+        ...                                                 input_columns=["image"])
         >>> # crop image to portrait style
         >>> transforms_list2 = [c_vision.Decode(), c_vision.CenterCrop((60, 40))]
-        >>> data2 = data2.map(operations=transforms_list2, input_columns=["image"])
+        >>> image_folder_dataset_1 = image_folder_dataset_1.map(operations=transforms_list2,
+        ...                                                     input_columns=["image"])
     """
 
     @check_crop
@@ -957,10 +937,9 @@ class RandomColor(cde.RandomColorOp):
             single fixed magnitude operation (default=(0.1, 1.9)).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomColor((0.5, 2.0))]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_positive_degrees
@@ -987,12 +966,13 @@ class RandomColorAdjust(cde.RandomColorAdjustOp):
             If it is a sequence, it should be [min, max] where -0.5 <= min <= max <= 0.5.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> decode_op = c_vision.Decode()
-        >>> transform_op = c_vision.RandomColorAdjust(brightness=(0.5, 1), contrast=(0.4, 1), saturation=(0.3, 1))
+        >>> transform_op = c_vision.RandomColorAdjust(brightness=(0.5, 1),
+        ...                                           contrast=(0.4, 1),
+        ...                                           saturation=(0.3, 1))
         >>> transforms_list = [decode_op, transform_op]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_color_adjust
@@ -1048,12 +1028,13 @@ class RandomRotation(cde.RandomRotationOp):
             If it is an integer, it is used for all RGB channels.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Inter
-        >>>
+        >>> from mindspore.dataset.vision import Inter
         >>> transforms_list = [c_vision.Decode(),
-        >>>                    c_vision.RandomRotation(degrees=5.0, resample=Inter.NEAREST, expand=True)]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        ...                    c_vision.RandomRotation(degrees=5.0,
+        ...                    resample=Inter.NEAREST,
+        ...                    expand=True)]
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_rotation
@@ -1082,10 +1063,9 @@ class Rescale(cde.RescaleOp):
         shift (float): Shift factor.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.Rescale(1.0 / 255.0, -1.0)]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_rescale
@@ -1122,14 +1102,14 @@ class RandomResize(cde.RandomResizeOp):
             If size is a sequence of length 2, it should be (height, width).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> # randomly resize image, keeping aspect ratio
         >>> transforms_list1 = [c_vision.Decode(), c_vision.RandomResize(50)]
-        >>> data1 = data1.map(operations=transforms_list1, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
+        ...                                                 input_columns=["image"])
         >>> # randomly resize image to landscape style
         >>> transforms_list2 = [c_vision.Decode(), c_vision.RandomResize((40, 60))]
-        >>> data2 = data2.map(operations=transforms_list2, input_columns=["image"])
+        >>> image_folder_dataset_1 = image_folder_dataset_1.map(operations=transforms_list2,
+        ...                                                     input_columns=["image"])
     """
 
     @check_resize
@@ -1152,14 +1132,14 @@ class RandomResizeWithBBox(cde.RandomResizeWithBBoxOp):
             If size is a sequence of length 2, it should be (height, width).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> # randomly resize image with bounding boxes, keeping aspect ratio
         >>> transforms_list1 = [c_vision.Decode(), c_vision.RandomResizeWithBBox(60)]
-        >>> data1 = data1.map(operations=transforms_list1, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
+        ...                                                 input_columns=["image"])
         >>> # randomly resize image with bounding boxes to portrait style
         >>> transforms_list2 = [c_vision.Decode(), c_vision.RandomResizeWithBBox((80, 60))]
-        >>> data2 = data2.map(operations=transforms_list2, input_columns=["image"])
+        >>> image_folder_dataset_1 = image_folder_dataset_1.map(operations=transforms_list2,
+        ...                                                     input_columns=["image"])
     """
 
     @check_resize
@@ -1175,11 +1155,12 @@ class HWC2CHW(cde.ChannelSwapOp):
     Transpose the input image; shape (H, W, C) to shape (C, H, W).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
-        >>> transforms_list = [c_vision.Decode(), c_vision.RandomHorizontalFlip(0.75), c_vision.RandomCrop(512),
-        >>>     c_vision.HWC2CHW()]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> transforms_list = [c_vision.Decode(),
+        ...                    c_vision.RandomHorizontalFlip(0.75),
+        ...                    c_vision.RandomCrop(512),
+        ...                    c_vision.HWC2CHW()]
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     def __call__(self, img):
@@ -1224,13 +1205,14 @@ class RandomCropDecodeResize(cde.RandomCropDecodeResizeOp):
             If exceeded, fall back to use center_crop instead.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Inter
-        >>>
-        >>> resize_crop_decode_op = c_vision.RandomCropDecodeResize(size=(50, 75), scale=(0.25, 0.5),
-        >>>     interpolation=Inter.NEAREST, max_attempts=5)
+        >>> from mindspore.dataset.vision import Inter
+        >>> resize_crop_decode_op = c_vision.RandomCropDecodeResize(size=(50, 75),
+        ...                                                         scale=(0.25, 0.5),
+        ...                                                         interpolation=Inter.NEAREST,
+        ...                                                         max_attempts=5)
         >>> transforms_list = [resize_crop_decode_op]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_resize_crop
@@ -1277,11 +1259,10 @@ class Pad(cde.PadOp):
               value of edge.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>> from mindspore.dataset.transforms.vision import Border
-        >>>
+        >>> from mindspore.dataset.vision import Border
         >>> transforms_list = [c_vision.Decode(), c_vision.Pad([100, 100, 100, 100])]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_pad
@@ -1321,18 +1302,17 @@ class UniformAugment(cde.UniformAugOp):
         num_ops (int, optional): Number of operations to be selected and applied (default=2).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
         >>> import mindspore.dataset.vision.py_transforms as py_vision
-        >>>
         >>> transforms_list = [c_vision.RandomHorizontalFlip(),
-        >>>                    c_vision.RandomVerticalFlip(),
-        >>>                    c_vision.RandomColorAdjust(),
-        >>>                    c_vision.RandomRotation(degrees=45)]
+        ...                    c_vision.RandomVerticalFlip(),
+        ...                    c_vision.RandomColorAdjust(),
+        ...                    c_vision.RandomRotation(degrees=45)]
         >>> uni_aug_op = c_vision.UniformAugment(transforms=transforms_list, num_ops=2)
         >>> transforms_all = [c_vision.Decode(), c_vision.Resize(size=[224, 224]),
-        >>>                   uni_aug_op, py_vision.ToTensor()]
-        >>> data_aug = data1.map(operations=transforms_all, input_columns="image",
-        >>>                      num_parallel_workers=1)
+        ...                   uni_aug_op, py_vision.ToTensor()]
+        >>> image_folder_dataset_1 = image_folder_dataset.map(operations=transforms_all,
+        ...                                                   input_columns="image",
+        ...                                                   num_parallel_workers=1)
     """
 
     @check_uniform_augment_cpp
@@ -1352,12 +1332,13 @@ class RandomSelectSubpolicy(cde.RandomSelectSubpolicyOp):
         policy (list(list(tuple(TensorOp,float))): List of sub-policies to choose from.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
-        >>> policy = [[(c_vision.RandomRotation((45, 45)), 0.5), (c_vision.RandomVerticalFlip(), 1),
-        >>>            (c_vision.RandomColorAdjust(), 0.8)],
-        >>>           [(c_vision.RandomRotation((90, 90)), 1), (c_vision.RandomColorAdjust(), 0.2)]]
-        >>> data_policy = data1.map(operations=c_vision.RandomSelectSubpolicy(policy), input_columns=["image"])
+        >>> policy = [[(c_vision.RandomRotation((45, 45)), 0.5),
+        ...            (c_vision.RandomVerticalFlip(), 1),
+        ...            (c_vision.RandomColorAdjust(), 0.8)],
+        ...           [(c_vision.RandomRotation((90, 90)), 1),
+        ...            (c_vision.RandomColorAdjust(), 0.2)]]
+        >>> image_folder_dataset_1 = image_folder_dataset.map(operations=c_vision.RandomSelectSubpolicy(policy),
+        ...                                                   input_columns=["image"])
     """
 
     @check_random_select_subpolicy_op
@@ -1385,14 +1366,14 @@ class SoftDvppDecodeResizeJpeg(cde.SoftDvppDecodeResizeJpegOp):
             If size is a sequence of length 2, it should be (height, width).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> # decode and resize image, keeping aspect ratio
         >>> transforms_list1 = [c_vision.Decode(), c_vision.SoftDvppDecodeResizeJpeg(70)]
-        >>> data1 = data1.map(operations=transforms_list1, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
+        ...                                                 input_columns=["image"])
         >>> # decode and resize to portrait style
         >>> transforms_list2 = [c_vision.Decode(), c_vision.SoftDvppDecodeResizeJpeg((80, 60))]
-        >>> data2 = data2.map(operations=transforms_list2, input_columns=["image"])
+        >>> image_folder_dataset_1 = image_folder_dataset_1.map(operations=transforms_list2,
+        ...                                                     input_columns=["image"])
     """
 
     @check_resize
@@ -1425,14 +1406,14 @@ class SoftDvppDecodeRandomCropResizeJpeg(cde.SoftDvppDecodeRandomCropResizeJpegO
             If exceeded, fall back to use center_crop instead.
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> # decode, randomly crop and resize image, keeping aspect ratio
         >>> transforms_list1 = [c_vision.Decode(), c_vision.SoftDvppDecodeRandomCropResizeJpeg(90)]
-        >>> data1 = data1.map(operations=transforms_list1, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list1,
+        ...                                                 input_columns=["image"])
         >>> # decode, randomly crop and resize to landscape style
         >>> transforms_list2 = [c_vision.Decode(), c_vision.SoftDvppDecodeRandomCropResizeJpeg((80, 100))]
-        >>> data2 = data2.map(operations=transforms_list2, input_columns=["image"])
+        >>> image_folder_dataset_1 = image_folder_dataset_1.map(operations=transforms_list2,
+        ...                                                     input_columns=["image"])
     """
 
     @check_soft_dvpp_decode_random_crop_resize_jpeg
@@ -1456,10 +1437,9 @@ class RandomSolarize(cde.RandomSolarizeOp):
             be in (min, max) format. If min=max, then it is a single fixed magnitude operation (default=(0, 255)).
 
     Examples:
-        >>> import mindspore.dataset.vision.c_transforms as c_vision
-        >>>
         >>> transforms_list = [c_vision.Decode(), c_vision.RandomSolarize(threshold=(10,100))]
-        >>> data1 = data1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns=["image"])
     """
 
     @check_random_solarize

mindspore/dataset/vision/py_transforms.py

@@ -58,11 +58,14 @@ class ToTensor:
         output_type (NumPy datatype, optional): The datatype of the NumPy output (default=np.float32).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(), py_vision.RandomHorizontalFlip(0.5),
-        >>>          py_vision.ToTensor()])
+        >>> # create a list of transformations to be applied to the "image" column of each data row
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                           py_vision.RandomHorizontalFlip(0.5),
+        ...                           py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __init__(self, output_type=np.float32):
@@ -89,13 +92,15 @@ class ToType:
         output_type (NumPy datatype): The datatype of the NumPy output, e.g. numpy.float32.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
         >>> import numpy as np
-        >>>
-        >>> Compose([py_vision.Decode(), py_vision.RandomHorizontalFlip(0.5),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.ToType(np.float32)])
+        >>> transforms_list =Compose([py_vision.Decode(),
+        ...                           py_vision.RandomHorizontalFlip(0.5),
+        ...                           py_vision.ToTensor(),
+        ...                           py_vision.ToType(np.float32)])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __init__(self, output_type):
@@ -119,11 +124,12 @@ class HWC2CHW:
     Transpose a NumPy image array; shape (H, W, C) to shape (C, H, W).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.HWC2CHW()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.HWC2CHW()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __call__(self, img):
@@ -145,11 +151,13 @@ class ToPIL:
 
     Examples:
         >>> # data is already decoded, but not in PIL image format
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.ToPIL(),  py_vision.RandomHorizontalFlip(0.5),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.ToPIL(),
+        ...                            py_vision.RandomHorizontalFlip(0.5),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __call__(self, img):
@@ -170,12 +178,13 @@ class Decode:
     Decode the input image to PIL image format in RGB mode.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomHorizontalFlip(0.5),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomHorizontalFlip(0.5),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __call__(self, img):
@@ -204,13 +213,14 @@ class Normalize:
             The standard deviation values must be in the range (0.0, 1.0].
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomHorizontalFlip(0.5),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262))])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomHorizontalFlip(0.5),
+        ...                            py_vision.ToTensor(),
+        ...                            py_vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262))])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_normalize_py
@@ -246,13 +256,14 @@ class NormalizePad:
         dtype (str): Set the output data type of image (default is "float32").
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomHorizontalFlip(0.5),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.NormalizePad((0.491, 0.482, 0.447), (0.247, 0.243, 0.262), "float32")])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomHorizontalFlip(0.5),
+        ...                            py_vision.ToTensor(),
+        ...                            py_vision.NormalizePad((0.491, 0.482, 0.447), (0.247, 0.243, 0.262), "float32")])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_normalizepad_py
@@ -308,12 +319,13 @@ class RandomCrop:
               value of edge.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomCrop(224),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomCrop(224),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_random_crop
@@ -350,12 +362,13 @@ class RandomHorizontalFlip:
         prob (float, optional): Probability of the image being flipped (default=0.5).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomHorizontalFlip(0.5),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomHorizontalFlip(0.5),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_prob
@@ -383,12 +396,13 @@ class RandomVerticalFlip:
         prob (float, optional): Probability of the image being flipped (default=0.5).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomVerticalFlip(0.5),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomVerticalFlip(0.5),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_prob
@@ -429,12 +443,13 @@ class Resize:
             - Inter.BICUBIC, means the interpolation method is bicubic interpolation.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.Resize(256),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.Resize(256),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_resize_interpolation
@@ -481,12 +496,13 @@ class RandomResizedCrop:
             crop area (default=10). If exceeded, fall back to use center crop instead.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomResizedCrop(224),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomResizedCrop(224),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_random_resize_crop
@@ -522,12 +538,13 @@ class CenterCrop:
             If size is a sequence of length 2, it should be (height, width).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.CenterCrop(64),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.CenterCrop(64),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_crop
@@ -566,12 +583,13 @@ class RandomColorAdjust:
             If it is a sequence, it should be [min, max] where -0.5 <= min <= max <= 0.5.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomColorAdjust(0.4, 0.4, 0.4, 0.1),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomColorAdjust(0.4, 0.4, 0.4, 0.1),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_random_color_adjust
@@ -629,12 +647,13 @@ class RandomRotation:
             If it is an integer, it is used for all RGB channels. Default is 0.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomRotation(30),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomRotation(30),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_random_rotation
@@ -668,13 +687,14 @@ class FiveCrop:
             If size is a sequence of length 2, it should be (height, width).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.FiveCrop(size=200),
-        >>>          # 4D stack of 5 images
-        >>>          lambda *images: numpy.stack([py_vision.ToTensor()(image) for image in images])])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.FiveCrop(size=200),
+        ...                            # 4D stack of 5 images
+        ...                            lambda *images: numpy.stack([py_vision.ToTensor()(image) for image in images])])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_crop
@@ -708,13 +728,14 @@ class TenCrop:
             if set to True (default=False).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.TenCrop(size=200),
-        >>>          # 4D stack of 10 images
-        >>>          lambda *images: numpy.stack([py_vision.ToTensor()(image) for image in images])])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.TenCrop(size=200),
+        ...                            # 4D stack of 10 images
+        ...                            lambda *images: numpy.stack([py_vision.ToTensor()(image) for image in images])])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_ten_crop
@@ -748,12 +769,13 @@ class Grayscale:
             Default is 1. If set to 3, the returned image has 3 identical RGB channels.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.Grayscale(3),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.Grayscale(3),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_num_channels
@@ -781,12 +803,13 @@ class RandomGrayscale:
         prob (float, optional): Probability of the image being converted to grayscale (default=0.1).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomGrayscale(0.3),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomGrayscale(0.3),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_prob
@@ -844,13 +867,14 @@ class Pad:
               value of edge.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          # adds 10 pixels (default black) to each side of the border of the image
-        >>>          py_vision.Pad(padding=10),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            # adds 10 pixels (default black) to each side of the border of the image
+        ...                            py_vision.Pad(padding=10),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_pad
@@ -891,12 +915,13 @@ class RandomPerspective:
             - Inter.BICUBIC, means the interpolation method is bicubic interpolation.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomPerspective(prob=0.1),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomPerspective(prob=0.1),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_random_perspective
@@ -944,12 +969,13 @@ class RandomErasing:
             erase_area (default=10). If exceeded, return the original image.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.RandomErasing(value='random')])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.ToTensor(),
+        ...                            py_vision.RandomErasing(value='random')])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_random_erasing
@@ -991,12 +1017,13 @@ class Cutout:
         num_patches (int, optional): Number of patches to be cut out of an image (default=1).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.Cutout(80)])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.ToTensor(),
+        ...                            py_vision.Cutout(80)])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_cutout
@@ -1040,13 +1067,19 @@ class LinearTransformation:
         mean_vector (numpy.ndarray): a NumPy ndarray of shape (D,) where D = C x H x W.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.Resize(256),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.LinearTransformation(transformation_matrix, mean_vector)])
+        >>> import numpy as np
+        >>> height, width = 32, 32
+        >>> dim = 3 * height * width
+        >>> transformation_matrix = np.ones([dim, dim])
+        >>> mean_vector = np.zeros(dim)
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.Resize((height,width)),
+        ...                            py_vision.ToTensor(),
+        ...                            py_vision.LinearTransformation(transformation_matrix, mean_vector)])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_linear_transform
@@ -1116,12 +1149,13 @@ class RandomAffine:
         TypeError: If fill_value is not a single integer or a 3-tuple.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1)),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1)),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_random_affine
@@ -1179,12 +1213,11 @@ class MixUp:
 
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
-        >>>
         >>> # Setup multi-batch mixup transformation
         >>> transform = [py_vision.MixUp(batch_size=16, alpha=0.2, is_single=False)]
         >>> # Apply the transform to the dataset through dataset.map()
-        >>> dataset = dataset.map(input_columns="image", operations=transform())
+        >>> image_folder_dataset = image_folder_dataset.map(input_columns="image",
+        ...                                                 operations=transform)
     """
 
     @check_mix_up
@@ -1222,13 +1255,14 @@ class RgbToHsv:
                        and (C, H, W) or (N, C, H, W) if False (default=False).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.CenterCrop(20),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.RgbToHsv()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.CenterCrop(20),
+        ...                            py_vision.ToTensor(),
+        ...                            py_vision.RgbToHsv()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __init__(self, is_hwc=False):
@@ -1257,13 +1291,14 @@ class HsvToRgb:
                        and (C, H, W) or (N, C, H, W) if False (default=False).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.CenterCrop(20),
-        >>>          py_vision.ToTensor(),
-        >>>          py_vision.HsvToRgb()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.CenterCrop(20),
+        ...                            py_vision.ToTensor(),
+        ...                            py_vision.HsvToRgb()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __init__(self, is_hwc=False):
@@ -1292,12 +1327,13 @@ class RandomColor:
             It should be in (min, max) format (default=(0.1,1.9)).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomColor((0.5, 2.0)),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomColor((0.5, 2.0)),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_positive_degrees
@@ -1327,12 +1363,13 @@ class RandomSharpness:
             It should be in (min, max) format (default=(0.1,1.9)).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.RandomSharpness((0.5, 1.5)),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.RandomSharpness((0.5, 1.5)),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_positive_degrees
@@ -1362,13 +1399,13 @@ class AutoContrast:
         ignore (Union[int, sequence], optional): Pixel values to ignore (default=None).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.AutoContrast(),
-        >>>          py_vision.ToTensor()])
-
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.AutoContrast(),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_auto_contrast
@@ -1395,13 +1432,13 @@ class Invert:
     Invert colors of input PIL image.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.Invert(),
-        >>>          py_vision.ToTensor()])
-
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.Invert(),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     def __call__(self, img):
@@ -1423,12 +1460,13 @@ class Equalize:
     Equalize the histogram of input PIL image.
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.Equalize(),
-        >>>          py_vision.ToTensor()])
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.Equalize(),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
 
     """
 
@@ -1459,16 +1497,17 @@ class UniformAugment:
          num_ops (int, optional): number of transforms to sequentially apply (default=2).
 
     Examples:
-        >>> import mindspore.dataset.vision.py_transforms as py_vision
         >>> from mindspore.dataset.transforms.py_transforms import Compose
-        >>>
-        >>> transforms_list = [py_vision.CenterCrop(64),
-        >>>                    py_vision.RandomColor(),
-        >>>                    py_vision.RandomSharpness(),
-        >>>                    py_vision.RandomRotation(30)]
-        >>> Compose([py_vision.Decode(),
-        >>>          py_vision.UniformAugment(transforms_list),
-        >>>          py_vision.ToTensor()])
+        >>> transforms = [py_vision.CenterCrop(64),
+        ...               py_vision.RandomColor(),
+        ...               py_vision.RandomSharpness(),
+        ...               py_vision.RandomRotation(30)]
+        >>> transforms_list = Compose([py_vision.Decode(),
+        ...                            py_vision.UniformAugment(transforms),
+        ...                            py_vision.ToTensor()])
+        >>> # apply the transform to dataset through map function
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list,
+        ...                                                 input_columns="image")
     """
 
     @check_uniform_augment_py