mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/dataset/engine/datasets_vision.py

@@ -32,14 +32,14 @@ import mindspore._c_dataengine as cde
 
 from .datasets import VisionBaseDataset, SourceDataset, MappableDataset, Shuffle, Schema
 from .datasets_user_defined import GeneratorDataset
-from .validators import check_imagefolderdataset, check_kittidataset,\
-    check_mnist_cifar_dataset, check_manifestdataset, check_vocdataset, check_cocodataset, \
-    check_celebadataset, check_flickr_dataset, check_sb_dataset, check_flowers102dataset, check_cityscapes_dataset, \
-    check_usps_dataset, check_div2k_dataset, check_random_dataset, \
-    check_sbu_dataset, check_qmnist_dataset, check_emnist_dataset, check_fake_image_dataset, check_places365_dataset, \
-    check_photo_tour_dataset, check_svhn_dataset, check_stl10_dataset, check_semeion_dataset, \
-    check_caltech101_dataset, check_caltech256_dataset, check_wider_face_dataset, check_lfw_dataset, \
-    check_lsun_dataset, check_omniglotdataset
+from .validators import check_caltech101_dataset, check_caltech256_dataset, check_celebadataset, \
+    check_cityscapes_dataset, check_cocodataset, check_div2k_dataset, check_emnist_dataset, check_fake_image_dataset, \
+    check_flickr_dataset, check_flowers102dataset, check_food101_dataset, check_imagefolderdataset, \
+    check_kittidataset, check_lfw_dataset, check_lsun_dataset, check_manifestdataset, check_mnist_cifar_dataset, \
+    check_omniglotdataset, check_photo_tour_dataset, check_places365_dataset, check_qmnist_dataset, \
+    check_random_dataset, check_rendered_sst2_dataset, check_sb_dataset, check_sbu_dataset, check_semeion_dataset, \
+    check_stl10_dataset, check_sun397_dataset, check_svhn_dataset, check_usps_dataset, check_vocdataset, \
+    check_wider_face_dataset
 
 from ..core.validator_helpers import replace_none
 
@@ -108,12 +108,14 @@ class _Caltech101Dataset:
 
 class Caltech101Dataset(GeneratorDataset):
     """
-    A source dataset that reads and parses Caltech101 dataset.
+    Caltech 101 dataset.
+
+    The columns of the generated dataset depend on the value of `target_type` .
+
+    - When `target_type` is 'category', the columns are :py:obj:`[image, category]` .
+    - When `target_type` is 'annotation', the columns are :py:obj:`[image, annotation]` .
+    - When `target_type` is 'all', the columns are :py:obj:`[image, category, annotation]` .
 
-    The columns of the generated dataset depend on the value of `target_type`.
-    When `target_type` is 'category', the columns are :py:obj:`[image, category]`.
-    When `target_type` is 'annotation', the columns are :py:obj:`[image, annotation]`.
-    When `target_type` is 'all', the columns are :py:obj:`[image, category, annotation]`.
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`category` is of the uint32 type.
     The tensor of column :py:obj:`annotation` is a 2-dimensional ndarray that stores the contour of the image
@@ -125,33 +127,33 @@ class Caltech101Dataset(GeneratorDataset):
             and the other is called Annotations, which stores annotations.
         target_type (str, optional): Target of the image. If `target_type` is 'category', return category represents
             the target class. If `target_type` is 'annotation', return annotation.
-            If `target_type` is 'all', return category and annotation (default=None, means 'category').
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data (default=1).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        decode (bool, optional): Whether or not to decode the images after reading (default=False).
+            If `target_type` is 'all', return category and annotation. Default: None, means 'category'.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker subprocesses to read the data. Default: 1.
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Whether or not to decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `target_type` is not set correctly.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        ValueError: If `target_type` is not set correctly.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -191,11 +193,13 @@ class Caltech101Dataset(GeneratorDataset):
 
     About Caltech101Dataset:
 
-    Pictures of objects belonging to 101 categories. About 40 to 800 images per category.
-    Most categories have about 50 images. Collected in September 2003 by Fei-Fei Li, Marco Andreetto,
-    and Marc 'Aurelio Ranzato. The size of each image is roughly 300 x 200 pixels.
+    Pictures of objects belonging to 101 categories, about 40 to 800 images per category.
+    Most categories have about 50 images. The size of each image is roughly 300 x 200 pixels.
     The official provides the contour data of each object in each picture, which is the annotation.
 
+    Here is the original Caltech101 dataset structure,
+    and you can unzip the dataset files into the following directory structure, which are read by MindSpore API.
+
     .. code-block::
 
         .
@@ -276,44 +280,45 @@ class Caltech101Dataset(GeneratorDataset):
 
 class Caltech256Dataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses Caltech256 dataset.
+    Caltech 256 dataset.
 
-    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The generated dataset has two columns: :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        decode (bool, optional): Whether or not to decode the images after reading (default=False).
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Whether or not to decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `target_type` is not 'category', 'annotation' or 'all'.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        ValueError: If `target_type` is not 'category', 'annotation' or 'all'.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -404,48 +409,49 @@ class Caltech256Dataset(MappableDataset, VisionBaseDataset):
 
 class CelebADataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses CelebA dataset.
-    Only support to read `list_attr_celeba.txt` currently, which is the attribute annotations of the dataset.
+    CelebA(CelebFaces Attributes) dataset.
 
-    The generated dataset has two columns: :py:obj:`[image, attr]`.
+    Only support to read `list_attr_celeba.txt` currently, which is the attribute annotations of the dataset.
+    The generated dataset has two columns: :py:obj:`[image, attr]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`attr` is of the uint32 type and one hot encoded.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        num_parallel_workers (int, optional): Number of workers to read the data (default=None, will use value set in
-            the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None).
-        usage (str, optional): Specify the 'train', 'valid', 'test' part or 'all' parts of dataset
-            (default= 'all', will read all samples).
-        sampler (Sampler, optional): Object used to choose samples from the dataset (default=None).
-        decode (bool, optional): Whether to decode the images after reading (default=False).
-        extensions (list[str], optional): List of file extensions to be included in the dataset (default=None).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will include all images).
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None.
+        usage (str, optional): Specify the 'train', 'valid', 'test' part or 'all' parts of dataset.
+            Default: 'all', will read all samples.
+        sampler (Sampler, optional): Object used to choose samples from the dataset. Default: None.
+        decode (bool, optional): Whether to decode the images after reading. Default: False.
+        extensions (list[str], optional): List of file extensions to be included in the dataset. Default: None.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will include all images.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
         decrypt (callable, optional): Image decryption function, which accepts the path of the encrypted image file
             and returns the decrypted bytes data. Default: None, no decryption.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
-        ValueError: If `usage` is not 'train', 'valid', 'test' or 'all'.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `usage` is not 'train', 'valid', 'test' or 'all'.
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -574,47 +580,48 @@ class CelebADataset(MappableDataset, VisionBaseDataset):
 
 class Cifar10Dataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses Cifar10 dataset.
-    This api only supports parsing Cifar10 file in binary version now.
+    CIFAR-10 dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    This api only supports parsing CIFAR-10 file in binary version now.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is a scalar of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all' . 'train' will read from 50,000
-            train samples, 'test' will read from 10,000 test samples, 'all' will read from all 60,000 samples
-            (default=None, all samples).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
+            train samples, 'test' will read from 10,000 test samples, 'all' will read from all 60,000 samples.
+            Default: None, all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
-        ValueError: If `usage` is not 'train', 'test' or 'all'.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `usage` is not 'train', 'test' or 'all'.
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -707,46 +714,47 @@ class Cifar10Dataset(MappableDataset, VisionBaseDataset):
 
 class Cifar100Dataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses Cifar100 dataset.
+    CIFAR-100 dataset.
 
-    The generated dataset has three columns :py:obj:`[image, coarse_label, fine_label]`.
+    The generated dataset has three columns :py:obj:`[image, coarse_label, fine_label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`coarse_label` and :py:obj:`fine_labels` are each a scalar of uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all' . 'train' will read from 50,000
-            train samples, 'test' will read from 10,000 test samples, 'all' will read from all 60,000 samples
-            (default=None, all samples).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
+            train samples, 'test' will read from 10,000 test samples, 'all' will read from all 60,000 samples.
+            Default: None, all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, 'num_samples' reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
-        ValueError: If `usage` is not 'train', 'test' or 'all'.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `usage` is not 'train', 'test' or 'all'.
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and shuffle
@@ -833,52 +841,54 @@ class Cifar100Dataset(MappableDataset, VisionBaseDataset):
 
 class CityscapesDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses Cityscapes dataset.
+    Cityscapes dataset.
 
-    The generated dataset has two columns :py:obj:`[image, task]`.
+    The generated dataset has two columns :py:obj:`[image, task]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`task` is of the uint8 type if task is not 'polygon' otherwise task is
     a string tensor with serialize json.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        usage (str): Acceptable usages include 'train', 'test', 'val' or 'all' if quality_mode is 'fine'
-            otherwise 'train', 'train_extra', 'val' or 'all' (default= 'train').
-        quality_mode (str): Acceptable quality_modes include 'fine' or 'coarse' (default= 'fine').
-        task (str): Acceptable tasks include 'instance', 'semantic', 'polygon' or 'color' (default= 'instance').
+        usage (str, optional): Acceptable usages include 'train', 'test', 'val' or 'all' if quality_mode is 'fine'
+            otherwise 'train', 'train_extra', 'val' or 'all'. Default: 'train'.
+        quality_mode (str, optional): Acceptable quality_modes include 'fine' or 'coarse'. Default: 'fine'.
+        task (str, optional): Acceptable tasks include 'instance',
+            'semantic', 'polygon' or 'color'. Default: 'instance'.
         num_samples (int, optional): The number of images to be included in the dataset.
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` is invalid or does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         ValueError: If `dataset_dir` is not exist.
         ValueError: If `task` is invalid.
         ValueError: If `quality_mode` is invalid.
         ValueError: If `usage` is invalid.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -1004,7 +1014,7 @@ class CityscapesDataset(MappableDataset, VisionBaseDataset):
 
 class CocoDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses COCO dataset.
+    COCO(Common Objects in Context) dataset.
 
     CocoDataset supports five kinds of tasks, which are Object Detection, Keypoint Detection, Stuff Segmentation,
     Panoptic Segmentation and Captioning of 2017 Train/Val/Test dataset.
@@ -1013,26 +1023,27 @@ class CocoDataset(MappableDataset, VisionBaseDataset):
         dataset_dir (str): Path to the root directory that contains the dataset.
         annotation_file (str): Path to the annotation JSON file.
         task (str, optional): Set the task type for reading COCO data. Supported task types:
-            'Detection', 'Stuff', 'Panoptic', 'Keypoint' and 'Captioning' (default='Detection').
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the configuration file).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
-        sampler (Sampler, optional): Object used to choose samples from the dataset
-            (default=None, expected order behavior shown in the table).
+            'Detection', 'Stuff', 'Panoptic', 'Keypoint' and 'Captioning'. Default: 'Detection'.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
         extra_metadata(bool, optional): Flag to add extra meta-data to row. If True, an additional column will be
-            output at the end :py:obj:`[_meta-filename, dtype=string]` (default=False).
+            output at the end :py:obj:`[_meta-filename, dtype=string]` . Default: False.
         decrypt (callable, optional): Image decryption function, which accepts the path of the encrypted image file
             and returns the decrypted bytes data. Default: None, no decryption.
 
@@ -1083,13 +1094,13 @@ class CocoDataset(MappableDataset, VisionBaseDataset):
         ValueError: If `task` is not in ['Detection', 'Stuff', 'Panoptic', 'Keypoint', 'Captioning'].
         ValueError: If `annotation_file` is not exist.
         ValueError: If `dataset_dir` is not exist.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - Column '[_meta-filename, dtype=string]' won't be output unless an explicit rename dataset op is added
           to remove the prefix('_meta-').
-        - CocoDataset doesn't support PKSampler.
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - Not support `mindspore.dataset.PKSampler` for `sampler` parameter yet.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -1249,37 +1260,38 @@ class CocoDataset(MappableDataset, VisionBaseDataset):
 
 class DIV2KDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses DIV2KDataset dataset.
+    DIV2K(DIVerse 2K resolution image) dataset.
 
-    The generated dataset has two columns :py:obj:`[hr_image, lr_image]`.
+    The generated dataset has two columns :py:obj:`[hr_image, lr_image]` .
     The tensor of column :py:obj:`hr_image` and the tensor of column :py:obj:`lr_image` are of the uint8 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        usage (str, optional): Acceptable usages include 'train', 'valid' or 'all' (default= 'train').
+        usage (str, optional): Acceptable usages include 'train', 'valid' or 'all'. Default: 'train'.
         downgrade (str, optional): Acceptable downgrades include 'bicubic', 'unknown', 'mild', 'difficult' or
-            'wild' (default= 'bicubic').
-        scale (str, optional): Acceptable scales include 2, 3, 4 or 8 (default=2).
+            'wild'. Default: 'bicubic'.
+        scale (str, optional): Acceptable scales include 2, 3, 4 or 8. Default: 2.
             When `downgrade` is 'bicubic', scale can be 2, 3, 4, 8.
             When `downgrade` is 'unknown', scale can only be 2, 3, 4.
             When `downgrade` is 'mild', 'difficult' or 'wild', scale can only be 4.
         num_samples (int, optional): The number of images to be included in the dataset.
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` is invalid or does not contain data files.
@@ -1294,10 +1306,10 @@ class DIV2KDataset(MappableDataset, VisionBaseDataset):
         ValueError: If `scale` is invalid.
         ValueError: If `scale` equal to 8 and downgrade not equal to 'bicubic'.
         ValueError: If `downgrade` in ['mild', 'difficult', 'wild'] and `scale` not equal to 4.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -1437,9 +1449,9 @@ class DIV2KDataset(MappableDataset, VisionBaseDataset):
 
 class EMnistDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the EMNIST dataset.
+    EMNIST(Extended MNIST) dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is a scalar of the uint32 type.
 
@@ -1447,33 +1459,35 @@ class EMnistDataset(MappableDataset, VisionBaseDataset):
         dataset_dir (str): Path to the root directory that contains the dataset.
         name (str): Name of splits for this dataset, can be 'byclass', 'bymerge', 'balanced', 'letters', 'digits'
             or 'mnist'.
-        usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all'.
-            (default=None, will read all samples).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+        usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all'.'train' will read from 60,000
+            train samples, 'test' will read from 10,000 test samples, 'all' will read from all 70,000 samples.
+            Default: None, will read all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -1572,44 +1586,45 @@ class FakeImageDataset(MappableDataset, VisionBaseDataset):
     """
     A source dataset for generating fake images.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`label` is a scalar of the uint32 type.
+    The column :py:obj:`label` is a scalar of the uint32 type.
 
     Args:
-        num_images (int, optional): Number of images to generate in the dataset (default=1000).
-        image_size (tuple, optional):  Size of the fake image (default=(224, 224, 3)).
-        num_classes (int, optional): Number of classes in the dataset (default=10).
-        base_seed (int, optional): Offsets the index-based random seed used to generate each image (default=0).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+        num_images (int, optional): Number of images to generate in the dataset. Default: 1000.
+        image_size (tuple, optional):  Size of the fake image. Default: (224, 224, 3).
+        num_classes (int, optional): Number of classes in the dataset. Default: 10.
+        base_seed (int, optional): Offsets the index-based random seed used to generate each image. Default: 0.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a sampler. 'sampler' and 'shuffle' are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -1639,8 +1654,6 @@ class FakeImageDataset(MappableDataset, VisionBaseDataset):
         >>> # Read 3 samples from FakeImage dataset
         >>> dataset = ds.FakeImageDataset(num_images=1000, image_size=(224,224,3),
         ...                               num_classes=10, base_seed=0, num_samples=3)
-        >>>
-        >>> # Note: In FakeImage dataset, each dictionary has keys "image" and "label"
     """
 
     @check_fake_image_dataset
@@ -1660,44 +1673,45 @@ class FakeImageDataset(MappableDataset, VisionBaseDataset):
 
 class FashionMnistDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the FASHION-MNIST dataset.
+    Fashion-MNIST dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`label` is a scalar of the uint32 type.
+    The column :py:obj:`label` is a scalar of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all'. 'train' will read from 60,000
             train samples, 'test' will read from 10,000 test samples, 'all' will read from all 70,000 samples.
-            (default=None, will read all samples)
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            Default: None, will read all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -1782,9 +1796,9 @@ class FashionMnistDataset(MappableDataset, VisionBaseDataset):
 
 class FlickrDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses Flickr8k and Flickr30k dataset.
+    Flickr8k and Flickr30k datasets.
 
-    The generated dataset has two columns :py:obj:`[image, annotation]`.
+    The generated dataset has two columns :py:obj:`[image, annotation]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`annotation` is a tensor which contains 5 annotations string,
     such as ["a", "b", "c", "d", "e"].
@@ -1793,22 +1807,23 @@ class FlickrDataset(MappableDataset, VisionBaseDataset):
         dataset_dir (str): Path to the root directory that contains the dataset.
         annotation_file (str): Path to the root directory that contains the annotation.
         num_samples (int, optional): The number of images to be included in the dataset.
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=None).
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: None.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` is not valid or does not contain data files.
@@ -1819,10 +1834,10 @@ class FlickrDataset(MappableDataset, VisionBaseDataset):
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         ValueError: If `dataset_dir` is not exist.
         ValueError: If `annotation_file` is not exist.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -2026,45 +2041,45 @@ class _Flowers102Dataset:
 
 class Flowers102Dataset(GeneratorDataset):
     """
-    A source dataset that reads and parses Flowers102 dataset.
+    Oxfird 102 Flower dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]` or three :py:obj:`[image, segmentation, label]`.
-    The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`segmentation` is of the uint8 type.
-    The tensor of column :py:obj:`label` is a scalar or a tensor of the uint32 type.
+    According to the given `task` configuration, the generated dataset has different output columns:
+    - `task` = 'Classification', output columns: `[image, dtype=uint8]` , `[label, dtype=uint32]` .
+    - `task` = 'Segmentation',
+    output columns: `[image, dtype=uint8]` , `[segmentation, dtype=uint8]` , `[label, dtype=uint32]` .
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        task (str): Specify the 'Classification' or 'Segmentation' task (default='Classification').
-        usage (str): Specify the 'train', 'valid', 'test' part or 'all' parts of dataset
-            (default='all', will read all samples).
-        num_samples (int, optional): The number of samples to be included in the dataset (default=None, all images).
-        num_parallel_workers (int, optional): Number of subprocesses used to fetch the dataset in parallel (default=1).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset. Random accessible input is required.
-            (default=None, expected order behavior shown in the table).
-        decode (bool, optional): Whether or not to decode the images and segmentations after reading (default=False).
-        sampler (Union[Sampler, Iterable], optional): Object used to choose samples from the dataset. Random accessible
-            input is required (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
-            Random accessible input is required. When this argument is specified, 'num_samples' reflects the max
-            sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This argument must be specified only
-            when num_shards is also specified. Random accessible input is required.
+        task (str, optional): Specify the 'Classification' or 'Segmentation' task. Default: 'Classification'.
+        usage (str, optional): Specify the 'train', 'valid', 'test' part or 'all' parts of dataset.
+            Default: 'all', will read all samples.
+        num_samples (int, optional): The number of samples to be included in the dataset. Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker subprocesses used to
+            fetch the dataset in parallel. Default: 1.
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Whether or not to decode the images and segmentations after reading. Default: False.
+        sampler (Union[Sampler, Iterable], optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
+            When this argument is specified, `num_samples` reflects the max sample number of per shard.
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This argument must be specified only
+            when `num_shards` is also specified.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a sampler. 'sampler' and 'shuffle' are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -2187,40 +2202,176 @@ class Flowers102Dataset(GeneratorDataset):
         return class_dict
 
 
+class Food101Dataset(MappableDataset, VisionBaseDataset):
+    """
+    Food101 dataset.
+
+    The generated dataset has two columns :py:obj:`[image, label]` .
+    The tensor of column :py:obj:`image` is of the uint8 type.
+    The tensor of column :py:obj:`label` is of the string type.
+
+    Args:
+        dataset_dir (str): Path to the root directory that contains the dataset.
+        usage (str, optional): Usage of this dataset, can be 'train', 'test', or 'all'. 'train' will read
+            from 75,750 samples, 'test' will read from 25,250 samples, and 'all' will read all 'train'
+            and 'test' samples. Default: None, will be set to 'all'.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. When this argument
+            is specified, `num_samples` reflects the maximum sample number of per shard. Default: None.
+        shard_id (int, optional): The shard ID within `num_shards` . This argument can only be specified
+            when `num_shards` is also specified. Default: None.
+        cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
+
+    Raises:
+        RuntimeError: If `dataset_dir` does not contain data files.
+        RuntimeError: If `sampler` and `shuffle` are specified at the same time.
+        RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
+        RuntimeError: If `num_shards` is specified but `shard_id` is None.
+        RuntimeError: If `shard_id` is specified but `num_shards` is None.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If the value of `usage` is not 'train', 'test', or 'all'.
+        ValueError: If `dataset_dir` is not exist.
+
+    Note:
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
+          The table below shows what input arguments are allowed and their expected behavior.
+
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
+       :widths: 25 25 50
+       :header-rows: 1
+
+       * - Parameter `sampler`
+         - Parameter `shuffle`
+         - Expected Order Behavior
+       * - None
+         - None
+         - random order
+       * - None
+         - True
+         - random order
+       * - None
+         - False
+         - sequential order
+       * - Sampler object
+         - None
+         - order defined by sampler
+       * - Sampler object
+         - True
+         - not allowed
+       * - Sampler object
+         - False
+         - not allowed
+
+    Examples:
+        >>> food101_dataset_dir = "/path/to/food101_dataset_directory"
+        >>>
+        >>> # Read 3 samples from Food101 dataset
+        >>> dataset = ds.Food101Dataset(dataset_dir=food101_dataset_dir, num_samples=3)
+
+    About Food101 dataset:
+
+    The Food101 is a dataset of 101 food categories, with 101,000 images.
+    There are 250 test imgaes and 750 training images in each class. All images were rescaled
+    to have a maximum side length of 512 pixels.
+
+    The following is the original Food101 dataset structure.
+    You can unzip the dataset files into this directory structure and read by MindSpore's API.
+
+    .. code-block::
+
+        .
+        └── food101_dir
+             ├── images
+             │    ├── apple_pie
+             │    │    ├── 1005649.jpg
+             │    │    ├── 1014775.jpg
+             │    │    ├──...
+             │    ├── baby_back_rips
+             │    │    ├── 1005293.jpg
+             │    │    ├── 1007102.jpg
+             │    │    ├──...
+             │    └──...
+             └── meta
+                  ├── train.txt
+                  ├── test.txt
+                  ├── classes.txt
+                  ├── train.json
+                  ├── test.json
+                  └── train.txt
+
+    Citation:
+
+    .. code-block::
+
+        @inproceedings{bossard14,
+        title     = {Food-101 -- Mining Discriminative Components with Random Forests},
+        author    = {Bossard, Lukas and Guillaumin, Matthieu and Van Gool, Luc},
+        booktitle = {European Conference on Computer Vision},
+        year      = {2014}
+        }
+    """
+
+    @check_food101_dataset
+    def __init__(self, dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None,
+                 decode=False, sampler=None, num_shards=None, shard_id=None, cache=None):
+        super().__init__(num_parallel_workers=num_parallel_workers, sampler=sampler, num_samples=num_samples,
+                         shuffle=shuffle, num_shards=num_shards, shard_id=shard_id, cache=cache)
+
+        self.dataset_dir = dataset_dir
+        self.usage = replace_none(usage, "all")
+        self.decode = replace_none(decode, False)
+
+    def parse(self, children=None):
+        return cde.Food101Node(self.dataset_dir, self.usage, self.decode, self.sampler)
+
+
 class ImageFolderDataset(MappableDataset, VisionBaseDataset):
     """
     A source dataset that reads images from a tree of directories.
     All images within one folder have the same label.
 
-    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The generated dataset has two columns: :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is of a scalar of uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         extensions (list[str], optional): List of file extensions to be
-            included in the dataset (default=None).
+            included in the dataset. Default: None.
         class_indexing (dict, optional): A str-to-int mapping from folder name to index
-            (default=None, the folder names will be sorted
+            Default: None, the folder names will be sorted
             alphabetically and each class will be given a
-            unique index starting from 0).
-        decode (bool, optional): Decode the images after reading (default=False).
+            unique index starting from 0.
+        decode (bool, optional): Decode the images after reading. Default: False.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
         decrypt (callable, optional): Image decryption function, which accepts the path of the encrypted image file
             and returns the decrypted bytes data. Default: None, no decryption.
 
@@ -2232,11 +2383,11 @@ class ImageFolderDataset(MappableDataset, VisionBaseDataset):
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         RuntimeError: If `class_indexing` is not a dictionary.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - The shape of the image column is [image_size] if decode flag is False, or [H,W,C] otherwise.
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -2322,14 +2473,34 @@ class ImageFolderDataset(MappableDataset, VisionBaseDataset):
         return cde.ImageFolderNode(self.dataset_dir, self.decode, self.sampler, self.extensions, self.class_indexing,
                                    self.decrypt)
 
+    def get_class_indexing(self):
+        """
+        Get the class index.
+
+        Returns:
+            dict, a str-to-int mapping from label name to index.
+
+        Examples:
+            >>> image_folder_dataset_dir = "/path/to/image_folder_dataset_directory"
+            >>>
+            >>> dataset = ds.ImageFolderDataset(dataset_dir=image_folder_dataset_dir)
+            >>> class_indexing = dataset.get_class_indexing()
+        """
+        if self.class_indexing is None or not self.class_indexing:
+            runtime_getter = self._init_tree_getters()
+            _class_indexing = runtime_getter[0].GetClassIndexing()
+            for pair in _class_indexing:
+                self.class_indexing[pair[0]] = pair[1][0]
+        return self.class_indexing
+
 
-class KITTIDataset(MappableDataset):
+class KITTIDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the KITTI dataset.
+    KITTI dataset.
 
-    When usage is "train", the generated dataset has multiple columns: :py:obj:`[image, label, truncated,
-    occluded, alpha, bbox, dimensions, location, rotation_y]`; When usage is "test", the generated dataset
-    has only one column: :py:obj:`[image]`.
+    When `usage` is "train", the generated dataset has multiple columns: :py:obj:`[image, label, truncated,
+    occluded, alpha, bbox, dimensions, location, rotation_y]` ; When `usage` is "test", the generated dataset
+    has only one column: :py:obj:`[image]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is of the uint32 type.
     The tensor of column :py:obj:`truncated` is of the float32 type.
@@ -2342,25 +2513,26 @@ class KITTIDataset(MappableDataset):
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        usage (str, optional): Usage of this dataset, can be `train` or `test`. `train` will read 7481
-            train samples, `test` will read from 7518 test samples without label (default=None, will use `train`).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will include all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
-        sampler (Sampler, optional): Object used to choose samples from the dataset
-            (default=None, expected order behavior shown in the table).
+        usage (str, optional): Usage of this dataset, can be `train` or `test` . `train` will read 7481
+            train samples, `test` will read from 7518 test samples without label. Default: None, will use `train` .
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will include all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, 'num_samples' reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within num_shards (default=None). This
-            argument can only be specified when num_shards is also specified.
+        shard_id (int, optional): The shard ID within `num_shards`. Default: None. This
+            argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
@@ -2368,10 +2540,10 @@ class KITTIDataset(MappableDataset):
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         ValueError: If `dataset_dir` is not exist.
-        ValueError: If `shard_id` is invalid (< 0 or >= num_shards).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -2418,13 +2590,14 @@ class KITTIDataset(MappableDataset):
     and a 3D laser scanner. Despite its popularity, the dataset itself does not contain ground truth for
     semantic segmentation. However, various researchers have manually annotated parts of the dataset to fit
     their necessities. Álvarez et al. generated ground truth for 323 images from the road detection challenge
-    with three classes: road, vertical,and sky. Zhang et al. annotated 252 (140 for training and 112 for testing)
+    with three classes: road, vehicles and sky. Zhang et al. annotated 252 (140 for training and 112 for testing)
     acquisitions – RGB and Velodyne scans – from the tracking challenge for ten object categories: building, sky,
     road, vegetation, sidewalk, car, pedestrian, cyclist, sign/pole, and fence.
 
     You can unzip the original KITTI dataset files into this directory structure and read by MindSpore's API.
 
     .. code-block::
+
         .
         └── kitti_dataset_directory
             ├── data_object_image_2
@@ -2472,44 +2645,45 @@ class KITTIDataset(MappableDataset):
 
 class KMnistDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the KMNIST dataset.
+    KMNIST(Kuzushiji-MNIST) dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`label` is a scalar of the uint32 type.
+    The column :py:obj:`label` is a scalar of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all' . 'train' will read from 60,000
             train samples, 'test' will read from 10,000 test samples, 'all' will read from all 70,000 samples.
-            (default=None, will read all samples)
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            Default: None, will read all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and sharding are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (out of range [0, `num_shards`]).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -2543,8 +2717,6 @@ class KMnistDataset(MappableDataset, VisionBaseDataset):
         >>>
         >>> # Read 3 samples from KMNIST dataset
         >>> dataset = ds.KMnistDataset(dataset_dir=kmnist_dataset_dir, num_samples=3)
-        >>>
-        >>> # Note: In kmnist_dataset dataset, each dictionary has keys "image" and "label"
 
     About KMNIST dataset:
 
@@ -2594,10 +2766,10 @@ class KMnistDataset(MappableDataset, VisionBaseDataset):
 
 class LFWDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the LFW dataset.
+    LFW(Labeled Faces in the Wild) dataset.
 
-    When task is "people", the generated dataset has two columns: :py:obj:`[image, label]`;
-    When task is "pairs", the generated dataset has three columns: :py:obj:`[image1, image2, label]`.
+    When `task` is 'people', the generated dataset has two columns: :py:obj:`[image, label]`;
+    When `task` is 'pairs', the generated dataset has three columns: :py:obj:`[image1, image2, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`image1` is of the uint8 type.
     The tensor of column :py:obj:`image2` is of the uint8 type.
@@ -2605,38 +2777,44 @@ class LFWDataset(MappableDataset, VisionBaseDataset):
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        task (str, optional): Set the task type of reading lfw data, support "people" and "pairs"
-            (default="people").
-        usage (str, optional): The image split to use, support "10fold", "train", "test" and "all"
-            (default="all", will read samples including train and test).
-        image_set (str, optional): Image set of image funneling to use, support "original", "funneled" or
-            "deepfunneled" (default="funneled", will read "funneled" set).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
+        task (str, optional): Set the task type of reading lfw data, support 'people' and 'pairs'.
+            Default: None, means 'people'.
+        usage (str, optional): The image split to use, support '10fold', 'train', 'test' and 'all'.
+            Default: None, will read samples including train and test.
+        image_set (str, optional): Type of image funneling to use, support 'original', 'funneled' or
+            'deepfunneled'. Default: None, will use 'funneled'.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, 'num_samples' reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within num_shards (default=None). This
-            argument can only be specified when num_shards is also specified.
+        shard_id (int, optional): The shard ID within `num_shards`. Default: None. This
+            argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
+        RuntimeError: If `dataset_dir` does not contain data files.
         RuntimeError: If sampler and shuffle are specified at the same time.
         RuntimeError: If sampler and sharding are specified at the same time.
-        RuntimeError: If num_shards is specified but shard_id is None.
-        RuntimeError: If shard_id is specified but num_shards is None.
-        ValueError: If shard_id is invalid (< 0 or >= num_shards).
+        RuntimeError: If `num_shards` is specified but shard_id is None.
+        RuntimeError: If `shard_id` is specified but num_shards is None.
+        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards` ).
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    Note:
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
+          The table below shows what input arguments are allowed and their expected behavior.
+
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -2674,15 +2852,17 @@ class LFWDataset(MappableDataset, VisionBaseDataset):
 
     About LFW dataset:
 
-    LFW is a database of photographs designed for studying the problem of
-    unconstrained recognition. This database was created and maintained by researchers at the University
-    of Massachusetts, Amherst (specific references are in Acknowledgments section). 13,233 images of 5,749
-    people were detected and centered by the Viola Jones detector and collected from the web. 1,680 of the
-    people pictured have two or more distinct photos in the dataset.
+    LFW (Labelled Faces in the Wild) dataset is one of the most commonly used and widely open datasets in
+    the field of face recognition. It was released by Gary B. Huang and his team at Massachusetts Institute
+    of Technology in 2007. The dataset includes nearly 50,000 images of 13,233 individuals, which are sourced
+    from various internet platforms and contain diverse environmental factors such as different poses, lighting
+    conditions, and angles. Most of the images in the dataset are frontal and cover a wide range of ages, genders,
+    and ethnicities.
 
     You can unzip the original LFW dataset files into this directory structure and read by MindSpore's API.
 
     .. code-block::
+
         .
         └── lfw_dataset_directory
             ├── lfw
@@ -2749,45 +2929,51 @@ class LFWDataset(MappableDataset, VisionBaseDataset):
 
 class LSUNDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the LSUN dataset.
+    LSUN(Large-scale Scene UNderstarding) dataset.
 
-    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The generated dataset has two columns: :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is of a scalar of uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        usage (str, optional): Usage of this dataset, can be `train`, `test`, `valid` or `all`
-            (default=None, will be set to `all`).
-        classes(Union[str, list[str]], optional): Choose the specific classes to load (default=None, means loading
-            all classes in root directory).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
+        usage (str, optional): Usage of this dataset, can be `train` , `test` , `valid` or `all`
+            Default: None, will be set to `all` .
+        classes (Union[str, list[str]], optional): Choose the specific classes to load. Default: None, means loading
+            all classes in root directory.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, 'num_samples' reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within num_shards (default=None). This
-            argument can only be specified when num_shards is also specified.
+        shard_id (int, optional): The shard ID within `num_shards`. Default: None. This
+            argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
-        RuntimeError: If 'sampler' and 'shuffle' are specified at the same time.
-        RuntimeError: If 'sampler' and sharding are specified at the same time.
-        RuntimeError: If 'num_shards' is specified but 'shard_id' is None.
-        RuntimeError: If 'shard_id' is specified but 'num_shards' is None.
-        ValueError: If 'shard_id' is invalid (< 0 or >= num_shards).
-        ValueError: If 'usage' or 'classes' is invalid (not in specific types).
-
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+        RuntimeError: If `dataset_dir` does not contain data files.
+        RuntimeError: If `sampler` and `shuffle` are specified at the same time.
+        RuntimeError: If `sampler` and sharding are specified at the same time.
+        RuntimeError: If `num_shards` is specified but `shard_id` is None.
+        RuntimeError: If `shard_id` is specified but `num_shards` is None.
+        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards` ).
+        ValueError: If `usage` or `classes` is invalid (not in specific types).
+
+    Note:
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
+          The table below shows what input arguments are allowed and their expected behavior.
+
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -2826,15 +3012,17 @@ class LSUNDataset(MappableDataset, VisionBaseDataset):
 
     About LSUN dataset:
 
-    The LSUN dataset accesses the effectiveness of this cascading procedure and enables further progress
-    in visual recognition research.
+    The LSUN (Large-Scale Scene Understanding) is a large-scale dataset used for indoors scene
+    understanding. It was originally launched by Stanford University in 2015 with the aim of
+    providing a challenging and diverse dataset for research in computer vision and machine
+    learning. The main application of this dataset for research is indoor scene analysis.
 
-    The LSUN dataset contains around one million labeled images for each of 10 scene categories
-    and 20 object categories. The author experimented with training popular convolutional networks and found
-    that they achieved substantial performance gains when trained on this dataset.
+    This dataset contains ten different categories of scenes, including bedrooms, living rooms,
+    restaurants, lounges, studies, kitchens, bathrooms, corridors, children's room, and outdoors.
+    Each category contains tens of thousands of images from different perspectives, and these
+    images are high-quality, high-resolusion real-world images.
 
-    You can unzip the original LSUN dataset files into this directory structure using official data.py and
-    read by MindSpore's API.
+    You can unzip the dataset files into this directory structure and read by MindSpore's API.
 
     .. code-block::
 
@@ -2882,33 +3070,34 @@ class ManifestDataset(MappableDataset, VisionBaseDataset):
     """
     A source dataset for reading images from a Manifest file.
 
-    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The generated dataset has two columns: :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is of a scalar of uint64 type.
 
     Args:
         dataset_file (str): File to be read.
-        usage (str, optional): Acceptable usages include 'train', 'eval' and 'inference' (default= 'train').
+        usage (str, optional): Acceptable usages include 'train', 'eval' and 'inference'. Default: 'train'.
         num_samples (int, optional): The number of images to be included in the dataset.
-            (default=None, will include all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
+            Default: None, will include all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        class_indexing (dict, optional): A str-to-int mapping from label name to index
-            (default=None, the folder names will be sorted alphabetically and each
-            class will be given a unique index starting from 0).
-        decode (bool, optional): decode the images after reading (default=False).
+            dataset. Default: None, expected order behavior shown in the table below.
+        class_indexing (dict, optional): A str-to-int mapping from label name to index.
+            Default: None, the folder names will be sorted alphabetically and each
+            class will be given a unique index starting from 0.
+        decode (bool, optional): decode the images after reading. Default: False.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max number of samples per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If dataset_files are not valid or do not exist.
@@ -2918,11 +3107,11 @@ class ManifestDataset(MappableDataset, VisionBaseDataset):
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         RuntimeError: If class_indexing is not a dictionary.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - The shape of the image column is [image_size] if decode flag is False, or [H,W,C] otherwise.
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -2959,6 +3148,26 @@ class ManifestDataset(MappableDataset, VisionBaseDataset):
         >>>
         >>> # 2) Read samples (specified in manifest_file.manifest) for shard 0 in a 2-way distributed training setup
         >>> dataset = ds.ManifestDataset(dataset_file=manifest_dataset_dir, num_shards=2, shard_id=0)
+
+    About Manifest dataset:
+
+    Manifest file contains a list of files included in a dataset, including basic file info such as File name and File
+    ID, along with extended file metadata. Manifest is a data format file supported by Huawei Modelarts. For details,
+    see `Specifications for Importing the Manifest File <https://support.huaweicloud.com/engineers-modelarts/
+    modelarts_23_0009.html>`_ .
+
+    .. code-block::
+
+        .
+        └── manifest_dataset_directory
+            ├── train
+            │    ├── 1.JPEG
+            │    ├── 2.JPEG
+            │    ├── ...
+            ├── eval
+            │    ├── 1.JPEG
+            │    ├── 2.JPEG
+            │    ├── ...
     """
 
     @check_manifestdataset
@@ -3000,9 +3209,9 @@ class ManifestDataset(MappableDataset, VisionBaseDataset):
 
 class MnistDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the MNIST dataset.
+    MNIST dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is a scalar of the uint32 type.
 
@@ -3010,22 +3219,23 @@ class MnistDataset(MappableDataset, VisionBaseDataset):
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all' . 'train' will read from 60,000
             train samples, 'test' will read from 10,000 test samples, 'all' will read from all 70,000 samples.
-            (default=None, will read all samples)
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+            Default: None, will read all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
@@ -3035,10 +3245,10 @@ class MnistDataset(MappableDataset, VisionBaseDataset):
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but shard_id is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -3120,42 +3330,44 @@ class MnistDataset(MappableDataset, VisionBaseDataset):
         return cde.MnistNode(self.dataset_dir, self.usage, self.sampler)
 
 
-class OmniglotDataset(MappableDataset):
+class OmniglotDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the Omniglot dataset.
+    Omniglot dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is a scalar of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        background(bool, optional): Use the background dataset or the evaluation dataset
-            (default=None, will use the background dataset).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
+        background (bool, optional): Whether to create dataset from the "background" set.
+            Otherwise create from the "evaluation" set. Default: None, set to True.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, 'num_samples' reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within num_shards (default=None). This
-            argument can only be specified when num_shards is also specified.
+        shard_id (int, optional): The shard ID within `num_shards`. Default: None. This
+            argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
+        RuntimeError: If `dataset_dir` does not contain data files.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `sharding` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - This dataset can take in a sampler. `sampler` and `shuffle` are mutually exclusive.
@@ -3194,14 +3406,15 @@ class OmniglotDataset(MappableDataset):
 
     About Omniglot dataset:
 
-    The Omniglot dataset is designed for developing more human-like learning algorithms. Omniglot is a large dataset
-    of hand-written characters with 1623 characters and 20 examples for each character. These characters are collected
-    based upon 50 alphabets from different countries. It contains both images and strokes data. Stroke data are
-    coordinates with time in milliseconds.
+    The Omniglot dataset is designed for developing more human-like learning algorithms. It contains 1623 different
+    handwritten characters from 50 different alphabets. Each of the 1623 characters was drawn online via Amazon's
+    Mechanical Turk by 20 different people. Each image is paired with stroke data, a sequences of [x, y, t] coordinates
+    with time in milliseconds.
 
     You can unzip the original Omniglot dataset files into this directory structure and read by MindSpore's API.
 
     .. code-block::
+
         .
         └── omniglot_dataset_directory
              ├── images_background/
@@ -3252,43 +3465,41 @@ class OmniglotDataset(MappableDataset):
 
 class PhotoTourDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the PhotoTour dataset.
+    PhotoTour dataset.
 
-    The generated dataset with different usage has different output columns.
-    If train, the generated dataset has one column :py:obj:`[image]`,
-    else three columns :py:obj:`[image1, image2, matches]`.
-    The tensor of column :py:obj:`image`, :py:obj:`image1` and :py:obj:`image2` is of the uint8 type.
-    The tensor of column :py:obj:`matches` is a scalar of the uint32 type.
+    According to the given `usage` configuration, the generated dataset has different output columns:
+    - `usage` = 'train', output columns: `[image, dtype=uint8]` .
+    - `usage` ≠ 'train', output columns: `[image1, dtype=uint8]` , `[image2, dtype=uint8]` , `[matches, dtype=uint32]` .
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         name (str): Name of the dataset to load,
             should be one of 'notredame', 'yosemite', 'liberty', 'notredame_harris',
             'yosemite_harris' or 'liberty_harris'.
-        usage (str, optional): Usage of the dataset, can be 'train' or 'test' (Default=None, will be set to 'train').
+        usage (str, optional): Usage of the dataset, can be 'train' or 'test'. Default: None, will be set to 'train'.
             When usage is 'train', number of samples for each `name` is
             {'notredame': 468159, 'yosemite': 633587, 'liberty': 450092, 'liberty_harris': 379587,
             'yosemite_harris': 450912, 'notredame_harris': 325295}.
             When usage is 'test', will read 100,000 samples for testing.
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
@@ -3297,13 +3508,14 @@ class PhotoTourDataset(MappableDataset, VisionBaseDataset):
         ValueError: If `usage` is not in ["train", "test"].
         ValueError: If name is not in ["notredame", "yosemite", "liberty",
             "notredame_harris", "yosemite_harris", "liberty_harris"].
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a sampler. `sampler` and `shuffle` are mutually exclusive. The table
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive. The table
           below shows what input arguments are allowed and their expected behavior.
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 64 64 1
        :header-rows: 1
 
@@ -3333,9 +3545,6 @@ class PhotoTourDataset(MappableDataset, VisionBaseDataset):
         >>> # Read 3 samples from PhotoTour dataset.
         >>> dataset = ds.PhotoTourDataset(dataset_dir="/path/to/photo_tour_dataset_directory",
         ...                               name='liberty', usage='train', num_samples=3)
-        >>>
-        >>> # In PhotoTourDataset dataset, if usage is 'train', each dictionary has key "image",
-        >>> # else has keys "image1" "image2" and "matches".
 
     About PhotoTour dataset:
 
@@ -3407,49 +3616,50 @@ class PhotoTourDataset(MappableDataset, VisionBaseDataset):
 
 class Places365Dataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the Places365 dataset.
+    Places365 dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`label` is a scalar of the uint32 type.
+    The tensor of column :py:obj:`label` is of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        usage (str, optional): Usage of this dataset, can be 'train-standard', 'train-challenge' or 'val'
-            (default=None, will be set to 'train-standard').
-        small (bool, optional): Use 256 * 256 images (True) or high resolution images (False) (default=False).
-        decode (bool, optional): Decode the images after reading (default=True).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+        usage (str, optional): Usage of this dataset, can be 'train-standard', 'train-challenge' or 'val'.
+            Default: None, will be set to 'train-standard'.
+        small (bool, optional): Use 256 * 256 images (True) or high resolution images (False). Default: False.
+        decode (bool, optional): Decode the images after reading. Default: False.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
         ValueError: If `usage` is not in ["train-standard", "train-challenge", "val"].
 
     Note:
         - This dataset can take in a sampler. 'sampler' and 'shuffle' are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -3481,8 +3691,6 @@ class Places365Dataset(MappableDataset, VisionBaseDataset):
         >>> # Read 3 samples from Places365 dataset
         >>> dataset = ds.Places365Dataset(dataset_dir=place365_dataset_dir, usage='train-standard',
         ...                               small=True, decode=True, num_samples=3)
-        >>>
-        >>> # In places365 dataset, each dictionary has keys "image" and "label".
 
     About Places365 dataset:
 
@@ -3549,45 +3757,46 @@ class Places365Dataset(MappableDataset, VisionBaseDataset):
 
 class QMnistDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the QMNIST dataset.
+    QMNIST dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`label` is a scalar when `compat` is True else a tensor both of the uint32 type.
+    The tensor of column :py:obj:`label` is of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test', 'test10k', 'test50k', 'nist'
-            or 'all' (default=None, will read all samples).
+            or 'all'. Default: None, will read all samples.
         compat (bool, optional): Whether the label for each example is class number (compat=True) or the full QMNIST
-            information (compat=False) (default=True).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+            information (compat=False). Default: True.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -3678,26 +3887,49 @@ class RandomDataset(SourceDataset, VisionBaseDataset):
     A source dataset that generates random data.
 
     Args:
-        total_rows (int, optional): Number of samples for the dataset to generate
-            (default=None, number of samples is random).
-        schema (Union[str, Schema], optional): Path to the JSON schema file or schema object (default=None).
-            If the schema is not provided, the random dataset generates a random schema.
-        columns_list (list[str], optional): List of column names of the dataset
-            (default=None, the columns will be named like this "c0", "c1", "c2" etc).
-        num_samples (int, optional): The number of samples to be included in the dataset
-            (default=None, all samples).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
+        total_rows (int, optional): Number of samples for the dataset to generate.
+            Default: None, number of samples is random.
+        schema (Union[str, Schema], optional): Data format policy, which specifies the data types and shapes of the data
+            column to be read. Both JSON file path and objects constructed by mindspore.dataset.Schema are acceptable.
+            Default: None.
+        columns_list (list[str], optional): List of column names of the dataset.
+            Default: None, the columns will be named like this "c0", "c1", "c2" etc.
+        num_samples (int, optional): The number of samples to be included in the dataset.
+            Default: None, all samples.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, 'num_samples' reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
+
+    Raises:
+        RuntimeError: If `num_shards` is specified but `shard_id` is None.
+        RuntimeError: If `shard_id` is specified but `num_shards` is None.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+        TypeError: If `total_rows` is not of type int.
+        TypeError: If `num_shards` is not of type int.
+        TypeError: If `num_parallel_workers` is not of type int.
+        TypeError: If `shuffle` is not of type bool.
+        TypeError: If `columns_list` is not of type list.
+
+    Examples:
+        >>> from mindspore import dtype as mstype
+        >>> import mindspore.dataset as ds
+        >>>
+        >>> schema = ds.Schema()
+        >>> schema.add_column('image', de_type=mstype.uint8, shape=[2])
+        >>> schema.add_column('label', de_type=mstype.uint8, shape=[1])
+        >>> # apply dataset operations
+        >>> ds1 = ds.RandomDataset(schema=schema, total_rows=50, num_parallel_workers=4)
     """
 
     @check_random_dataset
@@ -3721,6 +3953,159 @@ class RandomDataset(SourceDataset, VisionBaseDataset):
         return cde.RandomNode(self.total_rows, schema, self.columns_list)
 
 
+class RenderedSST2Dataset(MappableDataset, VisionBaseDataset):
+    """
+    RenderedSST2(Rendered Stanford Sentiment Treebank v2) dataset.
+
+    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The tensor of column :py:obj:`image` is of the uint8 type.
+    The tensor of column :py:obj:`label` is of the uint32 type.
+
+    Args:
+        dataset_dir (str): Path to the root directory that contains the dataset.
+        usage (str, optional): Usage of this dataset, can be 'train', 'val', 'test' or 'all'.
+            Default: None, will read all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will include all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Whether or not to decode the images after reading. Default: False.
+        sampler (Sampler, optional): Object used to choose samples from the
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided
+            into. When this argument is specified, `num_samples` reflects
+            the maximum sample number of per shard. Default: None.
+        shard_id (int, optional): The shard ID within `num_shards` . This
+            argument can only be specified when `num_shards` is also specified. Default: None.
+        cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
+
+    Raises:
+        RuntimeError: If `dataset_dir` does not contain data files.
+        ValueError: If `usage` is not 'train', 'test', 'val' or 'all'.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        RuntimeError: If `sampler` and `shuffle` are specified at the same time.
+        RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
+        RuntimeError: If `num_shards` is specified but `shard_id` is None.
+        RuntimeError: If `shard_id` is specified but `num_shards` is None.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+
+    Note:
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
+          The table below shows what input arguments are allowed and their expected behavior.
+
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
+       :widths: 25 25 50
+       :header-rows: 1
+
+       * - Parameter `sampler`
+         - Parameter `shuffle`
+         - Expected Order Behavior
+       * - None
+         - None
+         - random order
+       * - None
+         - True
+         - random order
+       * - None
+         - False
+         - sequential order
+       * - Sampler object
+         - None
+         - order defined by sampler
+       * - Sampler object
+         - True
+         - not allowed
+       * - Sampler object
+         - False
+         - not allowed
+
+    Examples:
+        >>> rendered_sst2_dataset_dir = "/path/to/rendered_sst2_dataset_directory"
+        >>>
+        >>> # 1) Read all samples (image files) in rendered_sst2_dataset_dir with 8 threads
+        >>> dataset = ds.RenderedSST2Dataset(dataset_dir=rendered_sst2_dataset_dir,
+        ...                                  usage="all", num_parallel_workers=8)
+
+    About RenderedSST2Dataset:
+
+    Rendered SST2 is an image classification dataset which was generated by rendering sentences in the Standford
+    Sentiment Treebank v2 dataset. There are three splits in this dataset and each split contains two classes
+    (positive and negative): a train split containing 6920 images (3610 positive and 3310 negative), a validation
+    split containing 872 images (444 positive and 428 negative), and a test split containing 1821 images
+    (909 positive and 912 negative).
+
+    Here is the original RenderedSST2 dataset structure.
+    You can unzip the dataset files into the following directory structure and read by MindSpore's API.
+
+    .. code-block::
+
+        .
+        └── rendered_sst2_dataset_directory
+             ├── train
+             │    ├── negative
+             │    │    ├── 0001.jpg
+             │    │    ├── 0002.jpg
+             │    │    ...
+             │    └── positive
+             │         ├── 0001.jpg
+             │         ├── 0002.jpg
+             │         ...
+             ├── test
+             │    ├── negative
+             │    │    ├── 0001.jpg
+             │    │    ├── 0002.jpg
+             │    │    ...
+             │    └── positive
+             │         ├── 0001.jpg
+             │         ├── 0002.jpg
+             │         ...
+             └── valid
+                  ├── negative
+                  │    ├── 0001.jpg
+                  │    ├── 0002.jpg
+                  │    ...
+                  └── positive
+                       ├── 0001.jpg
+                       ├── 0002.jpg
+                       ...
+
+    Citation:
+
+    .. code-block::
+
+        @inproceedings{socher-etal-2013-recursive,
+            title     = {Recursive Deep Models for Semantic Compositionality Over a Sentiment Treebank},
+            author    = {Socher, Richard and Perelygin, Alex and Wu, Jean and Chuang, Jason and Manning,
+                          Christopher D. and Ng, Andrew and Potts, Christopher},
+            booktitle = {Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing},
+            month     = oct,
+            year      = {2013},
+            address   = {Seattle, Washington, USA},
+            publisher = {Association for Computational Linguistics},
+            url       = {https://www.aclweb.org/anthology/D13-1170},
+            pages     = {1631--1642},
+        }
+    """
+
+    @check_rendered_sst2_dataset
+    def __init__(self, dataset_dir, usage=None, num_samples=None, num_parallel_workers=None, shuffle=None,
+                 decode=False, sampler=None, num_shards=None, shard_id=None, cache=None):
+        super().__init__(num_parallel_workers=num_parallel_workers, sampler=sampler, num_samples=num_samples,
+                         shuffle=shuffle, num_shards=num_shards, shard_id=shard_id, cache=cache)
+
+        self.dataset_dir = dataset_dir
+        self.usage = replace_none(usage, "all")
+        self.decode = replace_none(decode, False)
+
+    def parse(self, children=None):
+        return cde.RenderedSST2Node(self.dataset_dir, self.usage, self.decode, self.sampler)
+
+
 class _SBDataset:
     """
     Dealing with the data file with .mat extension, and return one row in tuple (image, task) each time.
@@ -3783,43 +4168,44 @@ class _SBDataset:
 
 class SBDataset(GeneratorDataset):
     """
-    A source dataset that reads and parses Semantic Boundaries Dataset.
+    SB(Semantic Boundaries) Dataset.
 
-    The generated dataset has two columns: :py:obj:`[image, task]`.
-    The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`task` contains 20 images of the uint8 type if `task` is 'Boundaries' otherwise
-    contains 1 image of the uint8 type.
+    By configuring the 'Task' parameter, the generated dataset has different output columns.
+
+    - 'task' = 'Boundaries' , there are two output columns: the 'image' column has the data type uint8 and
+      the 'label' column contains one image of the data type uint8.
+    - 'task' = 'Segmentation' , there are two output columns: the 'image' column has the data type uint8 and
+      the 'label' column contains 20 images of the data type uint8.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        task (str, optional): Acceptable tasks include 'Boundaries' or 'Segmentation' (default= 'Boundaries').
-        usage (str, optional): Acceptable usages include 'train', 'val', 'train_noval' and 'all' (default= 'all').
+        task (str, optional): Acceptable tasks include 'Boundaries' or 'Segmentation'. Default: 'Boundaries'.
+        usage (str, optional): Acceptable usages include 'train', 'val', 'train_noval' and 'all'. Default: 'all'.
         num_samples (int, optional): The number of images to be included in the dataset.
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=None).
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker subprocesses to read the data. Default: 1.
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: None.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
 
     Raises:
         RuntimeError: If `dataset_dir` is not valid or does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         ValueError: If `dataset_dir` is not exist.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         ValueError: If `task` is not in ['Boundaries', 'Segmentation'].
         ValueError: If `usage` is not in ['train', 'val', 'train_noval', 'all'].
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - This dataset can take in a sampler. `sampler` and `shuffle` are mutually exclusive.
@@ -3869,7 +4255,7 @@ class SBDataset(GeneratorDataset):
 
     The Semantic Boundaries Dataset consists of 11355 color images. There are 8498 images' name in the train.txt,
     2857 images' name in the val.txt and 5623 images' name in the train_noval.txt. The category cls/
-    contains the Segmentation and Boundaries results of category-level, the category inst/ catains the
+    contains the Segmentation and Boundaries results of category-level, the category inst/ contains the
     Segmentation and Boundaries results of instance-level.
 
     You can unzip the dataset files into the following structure and read by MindSpore's API:
@@ -3916,45 +4302,46 @@ class SBDataset(GeneratorDataset):
 
 class SBUDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the SBU dataset.
+    SBU(SBU Captioned Photo) dataset.
 
-    The generated dataset has two columns :py:obj:`[image, caption]`.
+    The generated dataset has two columns :py:obj:`[image, caption]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`caption` is of the string type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        decode (bool, optional): Decode the images after reading (default=False).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - This dataset can take in a sampler. 'sampler' and 'shuffle' are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -4031,42 +4418,43 @@ class SBUDataset(MappableDataset, VisionBaseDataset):
 
 class SemeionDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses Semeion dataset.
+    Semeion dataset.
 
-    The generated dataset has two columns :py:obj:`[image, label]`.
+    The generated dataset has two columns :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is a scalar of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        num_samples (int, optional): The number of samples to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
+        num_samples (int, optional): The number of samples to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -4153,9 +4541,9 @@ class SemeionDataset(MappableDataset, VisionBaseDataset):
 
 class STL10Dataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses STL10 dataset.
+    STL-10 dataset.
 
-    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The generated dataset has two columns: :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is of a scalar of int32 type.
 
@@ -4166,39 +4554,40 @@ class STL10Dataset(MappableDataset, VisionBaseDataset):
             train samples, 'test' will read from 8,000 test samples,
             'unlabeled' will read from all 100,000 samples, and 'train+unlabeled'
             will read from 105000 samples, 'all' will read all the samples
-            (default=None, all samples).
+            Default: None, all samples.
         num_samples (int, optional): The number of images to be included in the dataset.
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the
-            dataset (default=None, expected order behavior shown in the table).
+            dataset. Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, 'num_samples' reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` is not valid or does not exist or does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         ValueError: If `usage` is invalid.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - This dataset can take in a sampler. 'sampler' and 'shuffle' are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -4239,7 +4628,6 @@ class STL10Dataset(MappableDataset, VisionBaseDataset):
     About STL10 dataset:
 
     STL10 dataset consists of 10 classes: airplane, bird, car, cat, deer, dog, horse, monkey, ship, truck.
-    STL10 is is inspired by the CIFAR-10 dataset.
     Images are 96x96 pixels, color.
     500 training images, 800 test images per class and 100000 unlabeled images.
     Labels are 0-indexed, and unlabeled images have -1 as their labels.
@@ -4257,7 +4645,7 @@ class STL10Dataset(MappableDataset, VisionBaseDataset):
              ├── test_y.bin
              └── unlabeled_X.bin
 
-    Citation of STL10 dataset.
+    Citation of STL10 dataset:
 
     .. code-block::
 
@@ -4288,6 +4676,151 @@ class STL10Dataset(MappableDataset, VisionBaseDataset):
         return cde.STL10Node(self.dataset_dir, self.usage, self.sampler)
 
 
+class SUN397Dataset(MappableDataset, VisionBaseDataset):
+    """
+    SUN397(Scene UNderstanding) dataset.
+
+    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The tensor of column :py:obj:`image` is of the uint8 type.
+    The tensor of column :py:obj:`label` is of the uint32 type.
+
+    Args:
+        dataset_dir (str): Path to the root directory that contains the dataset.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Whether or not to decode the images after reading. Default: False.
+        sampler (Sampler, optional): Object used to choose samples from the
+            dataset. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided
+            into. When this argument is specified, `num_samples` reflects
+            the maximum sample number of per shard. Default: None.
+        shard_id (int, optional): The shard ID within `num_shards` . This
+            argument can only be specified when `num_shards` is also specified. Default: None.
+        cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
+
+    Raises:
+        RuntimeError: If `dataset_dir` does not contain data files.
+        RuntimeError: If `sampler` and `shuffle` are specified at the same time.
+        RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
+        RuntimeError: If `num_shards` is specified but `shard_id` is None.
+        RuntimeError: If `shard_id` is specified but `num_shards` is None.
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
+
+    Note:
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
+          The table below shows what input arguments are allowed and their expected behavior.
+
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
+       :widths: 25 25 50
+       :header-rows: 1
+
+       * - Parameter `sampler`
+         - Parameter `shuffle`
+         - Expected Order Behavior
+       * - None
+         - None
+         - random order
+       * - None
+         - True
+         - random order
+       * - None
+         - False
+         - sequential order
+       * - Sampler object
+         - None
+         - order defined by sampler
+       * - Sampler object
+         - True
+         - not allowed
+       * - Sampler object
+         - False
+         - not allowed
+
+    Examples:
+        >>> sun397_dataset_dir = "/path/to/sun397_dataset_directory"
+        >>>
+        >>> # 1) Read all samples (image files) in sun397_dataset_dir with 8 threads
+        >>> dataset = ds.SUN397Dataset(dataset_dir=sun397_dataset_dir, num_parallel_workers=8)
+
+    About SUN397Dataset:
+
+    The SUN397 or Scene UNderstanding (SUN) is a dataset for scene recognition consisting of 397 categories with
+    108,754 images. The number of images varies across categories, but there are at least 100 images per category.
+    Images are in jpg, png, or gif format.
+
+    Here is the original SUN397 dataset structure.
+    You can unzip the dataset files into this directory structure and read by MindSpore's API.
+
+    .. code-block::
+
+        .
+        └── sun397_dataset_directory
+            ├── ClassName.txt
+            ├── README.txt
+            ├── a
+            │   ├── abbey
+            │   │   ├── sun_aaaulhwrhqgejnyt.jpg
+            │   │   ├── sun_aacphuqehdodwawg.jpg
+            │   │   ├── ...
+            │   ├── apartment_building
+            │   │   └── outdoor
+            │   │       ├── sun_aamyhslnsnomjzue.jpg
+            │   │       ├── sun_abbjzfrsalhqivis.jpg
+            │   │       ├── ...
+            │   ├── ...
+            ├── b
+            │   ├── badlands
+            │   │   ├── sun_aabtemlmesogqbbp.jpg
+            │   │   ├── sun_afbsfeexggdhzshd.jpg
+            │   │   ├── ...
+            │   ├── balcony
+            │   │   ├── exterior
+            │   │   │   ├── sun_aaxzaiuznwquburq.jpg
+            │   │   │   ├── sun_baajuldidvlcyzhv.jpg
+            │   │   │   ├── ...
+            │   │   └── interior
+            │   │       ├── sun_babkzjntjfarengi.jpg
+            │   │       ├── sun_bagjvjynskmonnbv.jpg
+            │   │       ├── ...
+            │   └── ...
+            ├── ...
+
+
+    Citation:
+
+    .. code-block::
+
+        @inproceedings{xiao2010sun,
+        title        = {Sun database: Large-scale scene recognition from abbey to zoo},
+        author       = {Xiao, Jianxiong and Hays, James and Ehinger, Krista A and Oliva, Aude and Torralba, Antonio},
+        booktitle    = {2010 IEEE computer society conference on computer vision and pattern recognition},
+        pages        = {3485--3492},
+        year         = {2010},
+        organization = {IEEE}
+        }
+    """
+
+    @check_sun397_dataset
+    def __init__(self, dataset_dir, num_samples=None, num_parallel_workers=None, shuffle=None, decode=False,
+                 sampler=None, num_shards=None, shard_id=None, cache=None):
+        super().__init__(num_parallel_workers=num_parallel_workers, sampler=sampler, num_samples=num_samples,
+                         shuffle=shuffle, num_shards=num_shards, shard_id=shard_id, cache=cache)
+
+        self.dataset_dir = dataset_dir
+        self.decode = replace_none(decode, False)
+
+    def parse(self, children=None):
+        return cde.SUN397Node(self.dataset_dir, self.decode, self.sampler)
+
+
 class _SVHNDataset:
     """
     Mainly for loading SVHN Dataset, and return two rows each time.
@@ -4326,43 +4859,43 @@ class _SVHNDataset:
 
 class SVHNDataset(GeneratorDataset):
     """
-    A source dataset that reads and parses SVHN dataset.
+    SVHN(Street View House Numbers) dataset.
 
-    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The generated dataset has two columns: :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
     The tensor of column :py:obj:`label` is of a scalar of uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        usage (str, optional): Specify the 'train', 'test', 'extra' or 'all' parts of dataset
-            (default=None, will read all samples).
-        num_samples (int, optional): The number of samples to be included in the dataset (default=None, all images).
-        num_parallel_workers (int, optional): Number of subprocesses used to fetch the dataset in parallel (default=1).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset. Random accessible input is required.
-            (default=None, expected order behavior shown in the table).
+        usage (str, optional): Specify the 'train', 'test', 'extra' or 'all' parts of dataset.
+            Default: None, will read all samples.
+        num_samples (int, optional): The number of samples to be included in the dataset. Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker subprocesses used to
+            fetch the dataset in parallel. Default: 1.
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
         sampler (Sampler, optional): Object used to choose samples from the dataset. Random accessible
-            input is required (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
-            Random accessible input is required. When this argument is specified, 'num_samples' reflects the max
-            sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This argument must be specified only
-            when num_shards is also specified. Random accessible input is required.
+            input is required. Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
+            When this argument is specified, `num_samples` reflects the max sample number of per shard.
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This argument must be specified only
+            when `num_shards` is also specified.
 
     Raises:
         RuntimeError: If `dataset_dir` is not valid or does not exist or does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         ValueError: If `usage` is invalid.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - This dataset can take in a sampler. 'sampler' and 'shuffle' are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
-    .. list-table:: Expected Order Behavior of Using 'sampler' and 'shuffle'
+    .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
        :widths: 25 25 50
        :header-rows: 1
 
@@ -4394,9 +4927,7 @@ class SVHNDataset(GeneratorDataset):
 
     About SVHN dataset:
 
-    SVHN dataset consists of 10 digit classes.
-    SVHN is obtained from house numbers in Google Street View images.
-    73257 digits for training, 26032 digits for testing, and 531131 additional extra training data.
+    SVHN dataset consists of 10 digit classes and is obtained from house numbers in Google Street View images.
 
     Here is the original SVHN dataset structure.
     You can unzip the dataset files into this directory structure and read by MindSpore's API.
@@ -4438,54 +4969,53 @@ class SVHNDataset(GeneratorDataset):
 
 class USPSDataset(SourceDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses the USPS dataset.
+    USPS(U.S. Postal Service) dataset.
 
-    The generated dataset has two columns: :py:obj:`[image, label]`.
+    The generated dataset has two columns: :py:obj:`[image, label]` .
     The tensor of column :py:obj:`image` is of the uint8 type.
-    The tensor of column :py:obj:`label` is of a scalar of uint32 type.
+    The tensor of column :py:obj:`label` is of the uint32 type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test' or 'all'. 'train' will read from 7,291
             train samples, 'test' will read from 2,007 test samples, 'all' will read from all 9,298 samples.
-            (default=None, will read all samples)
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (Union[bool, Shuffle], optional): Perform reshuffling of the data every epoch
-            (default=Shuffle.GLOBAL). Bool type and Shuffle enum are both supported to pass in.
-            If shuffle is False, no shuffling will be performed;
-            If shuffle is True, the behavior is the same as setting shuffle to be Shuffle.GLOBAL
-            Otherwise, there are two levels of shuffling:
+            Default: None, will read all samples.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (Union[bool, Shuffle], optional): Perform reshuffling of the data every epoch.
+            Bool type and Shuffle enum are both supported to pass in. Default: `Shuffle.GLOBAL` .
+            If shuffle is False, no shuffling will be performed.
+            If shuffle is True, it is equivalent to setting `shuffle` to mindspore.dataset.Shuffle.GLOBAL.
+            Set the mode of data shuffling by passing in enumeration variables:
 
             - Shuffle.GLOBAL: Shuffle both the files and samples.
 
             - Shuffle.FILES: Shuffle files only.
 
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the max sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` is not valid or does not exist or does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
         ValueError: If `usage` is invalid.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Examples:
         >>> usps_dataset_dir = "/path/to/usps_dataset_directory"
         >>>
         >>> # Read 3 samples from USPS dataset
         >>> dataset = ds.USPSDataset(dataset_dir=usps_dataset_dir, num_samples=3)
-        >>>
-        >>> # Note: In USPS dataset, each dictionary has keys "image" and "label"
 
     About USPS dataset:
 
@@ -4535,52 +5065,53 @@ class USPSDataset(SourceDataset, VisionBaseDataset):
 
 class VOCDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses VOC dataset.
+    VOC(Visual Object Classes) dataset.
 
     The generated dataset with different task setting has different output columns:
 
-    - task = :py:obj:`Detection`, output columns: :py:obj:`[image, dtype=uint8]`, :py:obj:`[bbox, dtype=float32]`, \
-        :py:obj:`[label, dtype=uint32]`, :py:obj:`[difficult, dtype=uint32]`, :py:obj:`[truncate, dtype=uint32]`.
-    - task = :py:obj:`Segmentation`, output columns: :py:obj:`[image, dtype=uint8]`, :py:obj:`[target,dtype=uint8]`.
+    - task = :py:obj:`Detection` , output columns: :py:obj:`[image, dtype=uint8]` , :py:obj:`[bbox, dtype=float32]` , \
+        :py:obj:`[label, dtype=uint32]` , :py:obj:`[difficult, dtype=uint32]` , :py:obj:`[truncate, dtype=uint32]` .
+    - task = :py:obj:`Segmentation` , output columns: :py:obj:`[image, dtype=uint8]` , :py:obj:`[target,dtype=uint8]` .
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
-        task (str, optional): Set the task type of reading voc data, now only support 'Segmentation' or 'Detection'
-            (default= 'Segmentation').
-        usage (str, optional): Set the task type of ImageSets(default= 'train'). If task is 'Segmentation', image and
+        task (str, optional): Set the task type of reading voc data, now only support 'Segmentation' or 'Detection'.
+            Default: 'Segmentation'.
+        usage (str, optional): Set the task type of ImageSets. Default: 'train'. If task is 'Segmentation', image and
             annotation list will be loaded in ./ImageSets/Segmentation/usage + ".txt"; If task is 'Detection', image and
             annotation list will be loaded in ./ImageSets/Main/usage + ".txt"; if task and usage are not set, image and
             annotation list will be loaded in ./ImageSets/Segmentation/train.txt as default.
         class_indexing (dict, optional): A str-to-int mapping from label name to index, only valid in
-            'Detection' task (default=None, the folder names will be sorted alphabetically and each
-            class will be given a unique index starting from 0).
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, number set in the config).
-        shuffle (bool, optional): Whether to perform shuffle on the dataset (default=None, expected
-            order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
-        sampler (Sampler, optional): Object used to choose samples from the dataset
-            (default=None, expected order behavior shown in the table).
+            'Detection' task. Default: None, the folder names will be sorted alphabetically and each
+            class will be given a unique index starting from 0.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether to perform shuffle on the dataset. Default: None, expected
+            order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
         num_shards (int, optional): Number of shards that the dataset will be divided
-            into (default=None). When this argument is specified, `num_samples` reflects
+            into. Default: None. When this argument is specified, `num_samples` reflects
             the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This
             argument can only be specified when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
         extra_metadata(bool, optional): Flag to add extra meta-data to row. If True, an additional column named
-            :py:obj:`[_meta-filename, dtype=string]` will be output at the end (default=False).
+            :py:obj:`[_meta-filename, dtype=string]` will be output at the end. Default: False.
         decrypt (callable, optional): Image decryption function, which accepts the path of the encrypted image file
             and returns the decrypted bytes data. Default: None, no decryption.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
         RuntimeError: If xml of Annotations is an invalid format.
-        RuntimeError: If xml of Annotations loss attribution of `object`.
-        RuntimeError: If xml of Annotations loss attribution of `bndbox`.
+        RuntimeError: If xml of Annotations loss attribution of `object` .
+        RuntimeError: If xml of Annotations loss attribution of `bndbox` .
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
@@ -4589,12 +5120,12 @@ class VOCDataset(MappableDataset, VisionBaseDataset):
         ValueError: If task is not equal 'Segmentation' or 'Detection'.
         ValueError: If task equal 'Segmentation' but class_indexing is not None.
         ValueError: If txt related to mode is not exist.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
 
     Note:
         - Column '[_meta-filename, dtype=string]' won't be output unless an explicit rename dataset op
           is added to remove the prefix('_meta-').
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`
@@ -4643,7 +5174,7 @@ class VOCDataset(MappableDataset, VisionBaseDataset):
         >>> # In VOC dataset, if task='Segmentation', each dictionary has keys "image" and "target"
         >>> # In VOC dataset, if task='Detection', each dictionary has keys "image" and "annotation"
 
-    About VOC dataset.
+    About VOC dataset:
 
     The PASCAL Visual Object Classes (VOC) challenge is a benchmark in visual
     object category recognition and detection, providing the vision and machine
@@ -4741,56 +5272,50 @@ class VOCDataset(MappableDataset, VisionBaseDataset):
 
 class WIDERFaceDataset(MappableDataset, VisionBaseDataset):
     """
-    A source dataset that reads and parses WIDERFace dataset.
+    WIDERFace dataset.
 
     When usage is "train", "valid" or "all", the generated dataset has eight columns ["image", "bbox", "blur",
-    "expression", "illumination", "occlusion", "pose", "invalid"]. When usage is "test", it only has one column
-    ["image"].
-    The tensor of column :py:obj:`image` is a vector of the uint8 type.
-    The tensor of column :py:obj:`bbox` is a scalar of the uint32 type.
-    The tensor of column :py:obj:`blur` is a scalar of the uint32 type.
-    The tensor of column :py:obj:`expression` is a scalar of the uint32 type.
-    The tensor of column :py:obj:`illumination` is a scalar of the uint32 type.
-    The tensor of column :py:obj:`occlusion` is a scalar of the uint32 type.
-    The tensor of column :py:obj:`pose` is a scalar of the uint32 type.
-    The tensor of column :py:obj:`invalid` is a scalar of the uint32 type.
+    "expression", "illumination", "occlusion", "pose", "invalid"]. The data type of the `image` column is uint8,
+    and all other columns are uint32. When usage is "test", it only has one column
+    ["image"], with uint8 data type.
 
     Args:
         dataset_dir (str): Path to the root directory that contains the dataset.
         usage (str, optional): Usage of this dataset, can be 'train', 'test', 'valid' or 'all'. 'train' will read
             from 12,880 samples, 'test' will read from 16,097 samples, 'valid' will read from 3,226 test samples
-            and 'all' will read all 'train' and 'valid' samples (default=None, will be set to 'all').
-        num_samples (int, optional): The number of images to be included in the dataset
-            (default=None, will read all images).
-        num_parallel_workers (int, optional): Number of workers to read the data
-            (default=None, will use value set in the config).
-        shuffle (bool, optional): Whether or not to perform shuffle on the dataset
-            (default=None, expected order behavior shown in the table).
-        decode (bool, optional): Decode the images after reading (default=False).
-        sampler (Sampler, optional): Object used to choose samples from the dataset
-            (default=None, expected order behavior shown in the table).
-        num_shards (int, optional): Number of shards that the dataset will be divided into (default=None).
+            and 'all' will read all 'train' and 'valid' samples. Default: None, will be set to 'all'.
+        num_samples (int, optional): The number of images to be included in the dataset.
+            Default: None, will read all images.
+        num_parallel_workers (int, optional): Number of worker threads to read the data.
+            Default: None, will use global default workers(8), it can be set
+            by `mindspore.dataset.config.set_num_parallel_workers` .
+        shuffle (bool, optional): Whether or not to perform shuffle on the dataset.
+            Default: None, expected order behavior shown in the table below.
+        decode (bool, optional): Decode the images after reading. Default: False.
+        sampler (Sampler, optional): Object used to choose samples from the dataset.
+            Default: None, expected order behavior shown in the table below.
+        num_shards (int, optional): Number of shards that the dataset will be divided into. Default: None.
             When this argument is specified, `num_samples` reflects the maximum sample number of per shard.
-        shard_id (int, optional): The shard ID within `num_shards` (default=None). This argument can only be specified
+        shard_id (int, optional): The shard ID within `num_shards` . Default: None. This argument can only be specified
             when `num_shards` is also specified.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing. More details:
-            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r1.10/dataset/cache.html>`_
-            (default=None, which means no cache is used).
+            `Single-Node Data Cache <https://www.mindspore.cn/tutorials/experts/en/r2.0/dataset/cache.html>`_ .
+            Default: None, which means no cache is used.
 
     Raises:
         RuntimeError: If `dataset_dir` does not contain data files.
-        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         RuntimeError: If `sampler` and `shuffle` are specified at the same time.
         RuntimeError: If `sampler` and `num_shards`/`shard_id` are specified at the same time.
         RuntimeError: If `num_shards` is specified but `shard_id` is None.
         RuntimeError: If `shard_id` is specified but `num_shards` is None.
-        ValueError: If `shard_id` is invalid (< 0 or >= `num_shards`).
+        ValueError: If `shard_id` is not in range of [0, `num_shards` ).
         ValueError: If `usage` is not in ['train', 'test', 'valid', 'all'].
+        ValueError: If `num_parallel_workers` exceeds the max thread numbers.
         ValueError: If `annotation_file` is not exist.
         ValueError: If `dataset_dir` is not exist.
 
     Note:
-        - This dataset can take in a `sampler`. `sampler` and `shuffle` are mutually exclusive.
+        - This dataset can take in a `sampler` . `sampler` and `shuffle` are mutually exclusive.
           The table below shows what input arguments are allowed and their expected behavior.
 
     .. list-table:: Expected Order Behavior of Using `sampler` and `shuffle`