mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/dataset/engine/datasets.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -31,6 +31,7 @@ import json
 import os
 import signal
 import stat
+import warnings
 
 import gc
 import time
@@ -45,13 +46,13 @@ import copy
 import weakref
 import platform
 import psutil
-import numpy as np
 
 import mindspore._c_dataengine as cde
 from mindspore._c_expression import typing
 
 from mindspore import log as logger
-from mindspore.parallel._ps_context import _is_role_pserver, _is_role_sched, _get_ps_context, _enable_distributed_mindrt
+from mindspore.parallel._ps_context import _is_role_pserver, _is_role_sched, _get_ps_context,\
+                                           _enable_distributed_mindrt
 from mindspore.dataset.engine.offload import GetOffloadModel
 
 import mindspore.dataset.transforms.c_transforms as c_transforms
@@ -59,6 +60,7 @@ import mindspore.dataset.transforms.py_transforms as py_transforms
 import mindspore.dataset.transforms as transforms
 from mindspore.dataset.text.utils import SentencePieceModel, DE_C_INTER_SENTENCEPIECE_MODE
 from mindspore.parallel._utils import _get_device_num
+from mindspore.dataset.debug import DebugHook
 
 from . import samplers
 from .iterators import DictIterator, TupleIterator, DummyIterator, check_iterator_cleanup, _set_iterator_cleanup, \
@@ -67,9 +69,9 @@ from .queue import _SharedQueue, _Queue
 from .validators import check_batch, check_shuffle, check_map, check_filter, check_repeat, check_skip, check_zip, \
     check_rename, check_device_send, check_take, check_output_shape, check_project, \
     check_sync_wait, check_zip_dataset, check_add_column, check_concat, check_split, check_bucket_batch_by_length, \
-    check_save, check_tuple_iterator, check_dict_iterator, check_schema, check_to_device_send, deprecated
+    check_save, check_tuple_iterator, check_dict_iterator, check_schema, check_to_device_send, check_padded_batch
 from ..core.config import get_callback_timeout, _init_device_info, get_enable_shared_mem, get_num_parallel_workers, \
-    get_enable_watchdog, get_seed, set_seed
+    get_enable_watchdog, get_seed, set_seed, get_debug_mode, get_multiprocessing_timeout_interval, _get_debug_hook_list
 from ..core.datatypes import mstype_to_detype
 from ..core.validator_helpers import replace_none
 from ..core.py_util_helpers import ExceptionHandler
@@ -114,16 +116,19 @@ def _get_training_dataset():
     return _train_dataset
 
 
-def _reset_training_dataset(step):
+def _reset_training_dataset(global_step, dataset_size):
     """
-    Reset the training dataset to the given step number.
+    Reset the training dataset to the given global step.
 
     Args:
-        step (int): Global step number.
+        global_step (int): Number of global steps that have completed training.
+            Dataset will provide data from its next step after reset.
+        dataset_size (int): Number of steps per epoch.
     """
     dataset = _get_training_dataset()
     if dataset is not None:
-        dataset._reset(step)  # pylint: disable=W0212
+        epoch = global_step // dataset_size
+        dataset._reset(global_step, epoch)  # pylint: disable=protected-access
     else:
         raise RuntimeError("Training dataset is not set.")
 
@@ -227,7 +232,7 @@ def _get_operator_process():
     Inner implemented method, mainly for passing sub-process id in C layer
 
     Returns:
-         dict, mapping dict of operator id and corresponding process id.
+         dict, mapping dict of operation id and corresponding process id.
     """
     global _OP_PROCESS
     process_info = _OP_PROCESS
@@ -283,19 +288,20 @@ class Dataset:
                                                                      |
                                                               MappableDataset
 
-    DatasetOperator: MapDataset(UnionBaseDataset)
-                     BatchDataset(UnionBaseDataset)
-                     BucketBatchByLengthDataset(UnionBaseDataset)
-                     ShuffleDataset(UnionBaseDataset)
-                     FilterDataset(UnionBaseDataset)
-                     RepeatDataset(UnionBaseDataset)
-                     SkipDataset(UnionBaseDataset)
-                     TakeDataset(UnionBaseDataset)
-                     ZipDataset(UnionBaseDataset)
-                     ConcatDataset(UnionBaseDataset)
-                     RenameDataset(UnionBaseDataset)
-                     ProjectDataset(UnionBaseDataset)
-                     SyncWaitDataset(UnionBaseDataset)
+    DatasetOperation: MapDataset(UnionBaseDataset)
+                      BatchDataset(UnionBaseDataset)
+                      PaddedBatchDataset(UnionBaseDataset)
+                      BucketBatchByLengthDataset(UnionBaseDataset)
+                      ShuffleDataset(UnionBaseDataset)
+                      FilterDataset(UnionBaseDataset)
+                      RepeatDataset(UnionBaseDataset)
+                      SkipDataset(UnionBaseDataset)
+                      TakeDataset(UnionBaseDataset)
+                      ZipDataset(UnionBaseDataset)
+                      ConcatDataset(UnionBaseDataset)
+                      RenameDataset(UnionBaseDataset)
+                      ProjectDataset(UnionBaseDataset)
+                      SyncWaitDataset(UnionBaseDataset)
 
     Impl Dataset - vision:       ImageFolderDataset(MappableDataset, VisionBaseDataset)
                                  USPSDataset(SourceDataset, VisionBaseDataset)
@@ -309,8 +315,8 @@ class Dataset:
                                  NumpySlicesDataset(GeneratorDataset)
 
     Args:
-        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel
-            (default=None).
+        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel.
+            Default: None.
     """
 
     def __init__(self, children=None, num_parallel_workers=None, cache=None):
@@ -333,9 +339,6 @@ class Dataset:
         self.saved_output_shapes = None
         self.estimated_output_shapes = None
         self.runtime_context = None
-        self.dynamic_setting = [False, None]
-        self.saved_min_shapes = None
-        self.saved_max_shapes = None
         self._col_names = None
         self.dataset_size = None
         self._batch_size = None
@@ -347,7 +350,7 @@ class Dataset:
     @staticmethod
     def _get_operator_id(dataset):
         """
-        Internal method to iterate the tree and obtain op_id of each operator.
+        Internal method to iterate the tree and obtain op_id of each operation.
 
         Returns:
             Dataset, the root dataset of the tree.
@@ -379,18 +382,6 @@ class Dataset:
             _OP_PROCESS.update(generator_process)
         return op_name
 
-    def close_pool(self):
-        """
-        Close multiprocessing pool in dataset. If you are familiar with multiprocessing library, you can regard this
-        as a destructor for a processingPool object.
-
-        Note:
-            This interface will be deleted or invisible in the future. Please don't use it.
-            When you find that there are residual processes that do not exit correctly, you can use `kill -9 PROCESS_ID`
-            to end it, or through www.gitee.com/mindspore/mindspore send us an issue.
-        """
-        logger.warning("This interface will be deleted or invisible in the future. Please don't use it.")
-
     def create_ir_tree(self):
         """
         Internal method to build an IR tree.
@@ -444,7 +435,7 @@ class Dataset:
 
     @staticmethod
     def _noop_mode():
-        if _is_role_sched() or (_is_role_pserver() and not _enable_distributed_mindrt()):
+        if _is_role_sched():
             return True
         return False
 
@@ -459,10 +450,13 @@ class Dataset:
         Serialize a pipeline into JSON string and dump into file if filename is provided.
 
         Args:
-            filename (str): filename of JSON file to be saved as (default="").
+            filename (str): filename of JSON file to be saved as. Default: ''.
 
         Returns:
             str, JSON string of the pipeline.
+
+        Examples:
+            >>> dataset_json = dataset.to_json("/path/to/mnist_dataset_pipeline.json")
         """
         ir_tree, _ = self.create_ir_tree()
         return json.loads(ir_tree.to_json(filename))
@@ -495,7 +489,7 @@ class Dataset:
             element_length_function (Callable, optional): A function that takes in
                 M arguments where M = len(column_names) and returns an integer. If no value
                 provided, parameter M the len(column_names) must be 1, and the size of the first
-                dimension of that column will be taken as the length (default=None).
+                dimension of that column will be taken as the length. Default: None.
             pad_info (dict, optional): The information about how to batch each column. The key
                 corresponds to the column name, and the value must be a tuple of 2 elements.
                 The first element corresponds to the shape to pad to, and the second
@@ -503,17 +497,17 @@ class Dataset:
                 specified, then that column will be padded to the longest in the current
                 batch, and 0 will be used as the padding value. Any None dimensions will
                 be padded to the longest in the current batch, unless if
-                pad_to_bucket_boundary is True. If no padding is wanted, set pad_info
-                to None (default=None).
+                `pad_to_bucket_boundary` is True. If no padding is wanted, set pad_info
+                to None. Default: None.
             pad_to_bucket_boundary (bool, optional): If True, will pad each None
-                dimension in pad_info to the bucket_boundary minus 1. If there are any
-                elements that fall into the last bucket, an error will occur
-                (default=False).
+                dimension in `pad_info` to the bucket_boundary minus 1. If there are any
+                elements that fall into the last bucket, an error will occur.
+                Default: False.
             drop_remainder (bool, optional): If True, will drop the last batch for each
-                bucket if it is not a full batch (default=False).
+                bucket if it is not a full batch. Default: False.
 
         Returns:
-            Dataset, dataset bucketed and batched by length.
+            Dataset, dataset bucketized and batched by length.
 
         Examples:
             >>> # Create a dataset where certain counts rows are combined into a batch
@@ -541,14 +535,15 @@ class Dataset:
                                           element_length_function, pad_info, pad_to_bucket_boundary, drop_remainder)
 
     @check_batch
-    def batch(self, batch_size, drop_remainder=False, num_parallel_workers=None, per_batch_map=None,
-              input_columns=None, output_columns=None, column_order=None, pad_info=None,
-              python_multiprocessing=False, max_rowsize=16):
+    def batch(self, batch_size, drop_remainder=False, num_parallel_workers=None, **kwargs):
         """
-        Combine batch_size number of consecutive rows into batches.
+        Combine batch_size number of consecutive rows into batch which apply per_batch_map to the samples first.
 
         For any column, all the elements within that column must have the same shape.
-        If a per_batch_map callable is provided, it will be applied to the batches of tensors.
+
+        Refer to the following figure for the execution process:
+
+        .. image:: batch_en.png
 
         Note:
             The order of using repeat and batch reflects the number of batches and per_batch_map.
@@ -558,36 +553,39 @@ class Dataset:
             batch_size (Union[int, Callable]): The number of rows each batch is created with. An
                 int or callable object which takes exactly 1 parameter, BatchInfo.
             drop_remainder (bool, optional): Determines whether or not to drop the last block
-                whose data row number is less than batch size (default=False). If True, and if there are less
+                whose data row number is less than batch size. Default: False. If True, and if there are less
                 than batch_size rows available to make the last batch, then those rows will
                 be dropped and not propagated to the child node.
-            num_parallel_workers (int, optional): Number of workers(threads) to process the dataset in parallel
-                (default=None).
-            per_batch_map (Callable[[List[numpy.ndarray], ..., List[numpy.ndarray], BatchInfo], (List[numpy.ndarray],\
-                ..., List[numpy.ndarray])], optional): Per batch map callable (default=None). A callable
-                which takes (List[numpy.ndarray], ..., List[numpy.ndarray], BatchInfo) as input parameters. Each
-                list[numpy.ndarray] represents a batch of numpy.ndarray on a given column. The number of lists should
-                match with the number of entries in input_columns. The last parameter of the callable should always be
-                a BatchInfo object. Per_batch_map should return (list[numpy.ndarray], list[numpy.ndarray], ...). The
-                length of each list in output should be the same as the input. output_columns is required if the number
-                of output lists is different from input.
-            input_columns (Union[str, list[str]], optional): List of names of the input columns. The size of the list
-                should match with signature of per_batch_map callable (default=None).
-            output_columns (Union[str, list[str]], optional): List of names assigned to the columns
-                outputted by the last operation. This parameter is mandatory if len(input_columns) !=
-                len(output_columns). The size of this list must match the number of output
-                columns of the last operation. (default=None, output columns will have the same
-                name as the input columns, i.e., the columns will be replaced).
-            column_order (Union[str, list[str]], optional): Specifies the list of all the columns you need in the whole
-                dataset (default=None). The parameter is required when len(input_column) != len(output_column).
-                Caution: the list here is not just the columns specified in parameter input_columns and output_columns.
-            pad_info (dict, optional): Whether to perform padding on selected columns. pad_info={"col1":([224,224],0)}
-                would pad column with name "col1" to a tensor of size [224,224] and fill the missing with 0
-                (default=None).
-            python_multiprocessing (bool, optional): Parallelize Python function per_batch_map with multi-processing.
-                This option could be beneficial if the function is computational heavy (default=False).
-            max_rowsize(int, optional): Maximum size of row in MB that is used for shared memory allocation to copy
-               data between processes.  This is only used if python_multiprocessing is set to True (default=16).
+            num_parallel_workers (int, optional): Number of workers(threads) to process the dataset in parallel.
+                Default: None.
+            **kwargs:
+
+                - per_batch_map (Callable[[List[numpy.ndarray], ..., List[numpy.ndarray], BatchInfo], \
+                  (List[numpy.ndarray], ..., List[numpy.ndarray])], optional): Per batch map callable. Default: None.
+                  A callable which takes (List[numpy.ndarray], ..., List[numpy.ndarray], BatchInfo) as input parameters.
+                  Each list[numpy.ndarray] represents a batch of numpy.ndarray on a given column. The number of lists
+                  should match with the number of entries in input_columns. The last parameter of the callable should
+                  always be a BatchInfo object. Per_batch_map should return
+                  (list[numpy.ndarray], list[numpy.ndarray], ...). The length of each list in output should be the same
+                  as the input. output_columns is required if the number of output lists is different from input.
+
+                - input_columns (Union[str, list[str]], optional): List of names of the input columns. The size of
+                  the list should match with signature of per_batch_map callable. Default: None.
+
+                - output_columns (Union[str, list[str]], optional): List of names assigned to the columns
+                  outputted by the last operation. This parameter is mandatory if len(input_columns) !=
+                  len(output_columns). The size of this list must match the number of output
+                  columns of the last operation. Default: None, output columns will have the same
+                  name as the input columns, i.e., the columns will be replaced.
+
+                - python_multiprocessing (bool, optional): Parallelize Python function `per_batch_map` with
+                  multi-processing or multi-threading mode, True means multi-processing, False means multi-threading
+                  If `per_batch_map` is a I/O bound task, use multi-threading mode.
+                  If `per_batch_map` is a CPU bound task, it is recommended to use multi-processing mode.
+                  Default: False, use python multi-threading mode.
+
+                - max_rowsize(int, optional): Maximum size of row in MB that is used for shared memory allocation to
+                  copy data between processes. This is only used if python_multiprocessing is set to True. Default: 16.
 
         Returns:
             BatchDataset, dataset batched.
@@ -597,7 +595,7 @@ class Dataset:
             >>> # and drops the last incomplete batch if there is one.
             >>> dataset = dataset.batch(100, True)
             >>>
-            >>> # 2）resize image according to its batch number, if it's 5-th batch, resize to (5^2, 5^2) = (25, 25)
+            >>> # 2) resize image according to its batch number, if it's 5-th batch, resize to (5^2, 5^2) = (25, 25)
             >>> def np_resize(col, BatchInfo):
             ...     output = col.copy()
             ...     s = (BatchInfo.get_batch_num() + 1) ** 2
@@ -610,22 +608,64 @@ class Dataset:
             ...     return (output,)
             >>> dataset = dataset.batch(batch_size=8, input_columns=["image"], per_batch_map=np_resize)
             >>>
-            >>> # 3）Create a dataset where its batch size is dynamic
+            >>> # 3) Create a dataset where its batch size is dynamic
             >>> # Define a callable batch size function and let batch size increase 1 each time.
             >>> def add_one(BatchInfo):
             ...     return BatchInfo.get_batch_num() + 1
             >>> dataset = dataset.batch(batch_size=add_one, drop_remainder=True)
-            >>>
-            >>> # 4）Create a dataset with batch, then specify the column order.
-            >>> # Assume that the original coulmn order is ["image", "label"] and change to ["label", "image"].
-            >>> dataset = dataset.batch(32, column_order=["label", "image"])
         """
-        if pad_info is not None:
-            logger.warning("The parameter pad_info will be deprecated in the future. "
-                           "Please use '.map(operations=transforms.PadEnd(...), ...)' operation instead.")
+        return BatchDataset(self, batch_size, drop_remainder, num_parallel_workers, **kwargs)
+
+    @check_padded_batch
+    def padded_batch(self, batch_size, drop_remainder=False, num_parallel_workers=None, pad_info=None):
+        """
+        Combine batch_size number of consecutive rows into batch which apply pad_info to the samples first.
+
+        Refer to the following figure for the execution process:
 
-        return BatchDataset(self, batch_size, drop_remainder, num_parallel_workers, per_batch_map, input_columns,
-                            output_columns, column_order, pad_info, python_multiprocessing, max_rowsize)
+        .. image:: padded_batch_en.png
+
+        Note:
+            The order of using repeat and padded_batch reflects the number of batches.
+            It is recommended that the repeat operation applied after the padded_batch operation finished.
+
+        Args:
+            batch_size (Union[int, Callable]): The number of rows each batch is created with. An
+                int or callable object which takes exactly 1 parameter, BatchInfo.
+            drop_remainder (bool, optional): Determines whether or not to drop the last block
+                whose data row number is less than batch size. Default: False. If True, and if there are less
+                than batch_size rows available to make the last batch, then those rows will
+                be dropped and not propagated to the child node.
+            num_parallel_workers (int, optional): Number of workers(threads) to process the dataset in parallel.
+                Default: None.
+            pad_info (dict, optional): The information about how to batch each column. The key
+                corresponds to the column name, and the value must be a tuple of 2 elements.
+                The first element corresponds to the shape to pad to, and the second
+                element corresponds to the value to pad with. If a column is not
+                specified, then that column will be padded to the longest in the current
+                batch, and 0 will be used as the padding value. Any None dimensions will
+                be padded to the longest in the current batch, unless if
+                pad_to_bucket_boundary is True. If no padding is wanted, set pad_info
+                to None. Default: None.
+
+        Returns:
+            PaddedBatchDataset, dataset batched.
+
+        Examples:
+            >>> # 1) Pad every sample to the largest sample's shape and batch the samples
+            >>> dataset = dataset.padded_batch(100, True, pad_info={})
+            >>>
+            >>> # 2) Create a dataset where every 100 rows are combined into a batch
+            >>> # and drops the last incomplete batch if there is one.
+            >>> dataset = dataset.padded_batch(100, True)
+            >>>
+            >>> # 3) Create a dataset where its batch size is dynamic
+            >>> # Define a callable batch size function and let batch size increase 1 each time.
+            >>> def add_one(BatchInfo):
+            ...     return BatchInfo.get_batch_num() + 1
+            >>> dataset = dataset.padded_batch(batch_size=add_one, drop_remainder=True)
+        """
+        return PaddedBatchDataset(self, batch_size, drop_remainder, num_parallel_workers, pad_info)
 
     @check_sync_wait
     def sync_wait(self, condition_name, num_batch=1, callback=None):
@@ -634,8 +674,8 @@ class Dataset:
 
         Args:
             condition_name (str): The condition name that is used to toggle sending next row.
-            num_batch (int): the number of batches without blocking at the start of each epoch (default=1).
-            callback (function): The callback function that will be invoked when sync_update is called (default=None).
+            num_batch (int): the number of batches without blocking at the start of each epoch. Default: 1.
+            callback (function): The callback function that will be invoked when sync_update is called. Default: None.
 
         Returns:
             SyncWaitDataset, dataset added a blocking condition.
@@ -678,27 +718,27 @@ class Dataset:
     @check_shuffle
     def shuffle(self, buffer_size):
         """
-        Randomly shuffles the rows of this dataset using the following policy:
+        Shuffle the dataset by creating a cache with the size of `buffer_size` .
 
-        1. Make a shuffle buffer that contains the first buffer_size rows.
+        1. Make a shuffle buffer that contains the first `buffer_size` rows.
         2. Randomly select an element from the shuffle buffer to be the next row
            propagated to the child node.
         3. Get the next row (if any) from the parent node and put it in the shuffle buffer.
         4. Repeat steps 2 and 3 until there are no more rows left in the shuffle buffer.
 
-        A random seed can be provided to be used on the first epoch via `dataset.config.set_seed`. In every subsequent
+        A random seed can be provided to be used on the first epoch via `dataset.config.set_seed` . In every subsequent
         epoch, the seed is changed to a new one, randomly generated value.
 
         Args:
             buffer_size (int): The size of the buffer (must be larger than 1) for
-                shuffling. Setting buffer_size equal to the number of rows in the entire
+                shuffling. Setting `buffer_size` equal to the number of rows in the entire
                 dataset will result in a global shuffle.
 
         Returns:
             Dataset, dataset shuffled.
 
         Raises:
-            RuntimeError: If exist sync operators before shuffle.
+            RuntimeError: If exist sync operations before shuffle.
 
         Examples:
             >>> # dataset is an instance object of Dataset
@@ -715,7 +755,7 @@ class Dataset:
 
         Args:
             func (function): A function that must take one `numpy.ndarray` as an argument and
-                return a `Dataset`.
+                return a `Dataset` .
 
         Returns:
             Dataset, dataset applied by the function.
@@ -767,57 +807,77 @@ class Dataset:
 
     @check_map
     def map(self, operations, input_columns=None, output_columns=None, column_order=None,
-            num_parallel_workers=None, python_multiprocessing=False, cache=None, callbacks=None,
-            max_rowsize=16, offload=None):
+            num_parallel_workers=None, **kwargs):
         """
         Apply each operation in operations to this dataset.
 
         Each operation will be passed one or more columns from the dataset as input, and one or
         more columns will be outputted. The first operation will be passed the columns specified
-        in input_columns as input. If there is more than one operator in operations, the outputted
+        in input_columns as input. If there is more than one operation in operations, the outputted
         columns of the previous operation are used as the input columns for the next operation.
 
         The columns outputted by the very last operation will be assigned names specified by
-        `output_columns`, and if not specified, the column name of output column is same as that of `input_columns`.
+        `output_columns` , and if not specified, the column name of output column is same as that of `input_columns` .
+
+        - If you use transformations (
+          `vision transform <https://mindspore.cn/docs/en/r2.0/api_python/mindspore.\
+          dataset.transforms.html#module-mindspore.dataset.vision>`_ ,
+          `nlp transform <https://mindspore.cn/docs/en/r2.0/api_python/mindspore.\
+          dataset.transforms.html#module-mindspore.dataset.text>`_ ,
+          `audio transform <https://mindspore.cn/docs/en/r2.0/api_python/mindspore.\
+          dataset.transforms.html#module-mindspore.dataset.audio>`_ )
+          provided by mindspore dataset, please use the following parameters:
+
+          .. image:: map_parameter_en.png
+
+        - If you use user-defined transform as PyFunc (Python Func), please use the following parameters:
+
+          .. image:: map_parameter_pyfunc_en.png
 
         Args:
             operations (Union[list[TensorOperation], list[functions]]): List of operations to be
                 applied on the dataset. Operations are applied in the order they appear in this list.
             input_columns (Union[str, list[str]], optional): List of the names of the columns that will be passed to
                 the first operation as input. The size of this list must match the number of
-                input columns expected by the first operator. (default=None, the first
+                input columns expected by the first operation. Default: None, the first
                 operation will be passed however many columns that are required, starting from
-                the first column).
+                the first column.
             output_columns (Union[str, list[str]], optional): List of names assigned to the columns outputted by
                 the last operation. This parameter is mandatory if len(input_columns) !=
                 len(output_columns). The size of this list must match the number of output
-                columns of the last operation. (default=None, output columns will have the same
-                name as the input columns, i.e., the columns will be replaced).
-            column_order (Union[str, list[str]], optional): Specifies the list of all the columns you need in the whole
-                dataset (default=None). The parameter is required when len(input_column) != len(output_column).
-                Caution: the list here is not just the columns specified in parameter input_columns and output_columns.
+                columns of the last operation. Default: None, output columns will have the same
+                name as the input columns, i.e., the columns will be replaced.
             num_parallel_workers (int, optional): Number of threads used to process the dataset in
-                parallel (default=None, the value from the configuration will be used).
-            python_multiprocessing (bool, optional): Parallelize Python operations with multiple worker processes. This
-                option could be beneficial if the Python operation is computational heavy (default=False).
-            cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing.
-                (default=None, which means no cache is used).
-            callbacks (DSCallback, list[DSCallback], optional): List of Dataset callbacks to be called (Default=None).
-            max_rowsize (int, optional): Maximum size of row in MB that is used for shared memory allocation to copy
-               data between processes.  This is only used if python_multiprocessing is set to True (Default=16).
-            offload (bool, optional): Flag to indicate whether offload is used (Default=None).
+                parallel. Default: None, the value from the configuration will be used.
+            **kwargs:
+
+                - python_multiprocessing (bool, optional): Parallelize Python operations with multiple worker processes.
+                  This option could be beneficial if the Python operation is computational heavy. Default: False.
+
+                - max_rowsize (int, optional): Maximum size of row in MB that is used for shared memory allocation to
+                  copy data between processes.  This is only used if python_multiprocessing is set to True. Default: 16.
+
+                - cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing.
+                  Default: None, which means no cache is used.
+
+                - callbacks (DSCallback, list[DSCallback], optional): List of Dataset callbacks to be called.
+                  Default: None.
+
+                - offload (bool, optional): Flag to indicate whether offload is used. Default: None.
 
         Note:
             - Input `operations` accepts TensorOperations defined in mindspore.dataset part, plus user-defined
               Python functions (PyFuncs).
             - Do not add network computing operators from mindspore.nn and mindspore.ops or others into this
-              `operations`.
+              `operations` .
 
         Returns:
             Dataset, dataset after mapping operation.
 
         Examples:
             >>> # dataset is an instance of Dataset which has 2 columns, "image" and "label".
+            >>> # image is of type bytes type which can be decoded to RGB
+            >>> # label is of type int32
             >>>
             >>> # Define two operations, where each operation accepts 1 input column and outputs 1 column.
             >>> decode_op = c_vision.Decode(rgb=True)
@@ -826,30 +886,15 @@ class Dataset:
             >>>
             >>> # 1) Simple map example.
             >>>
-            >>> # Apply decode_op on column "image". This column will be replaced by the outputted
-            >>> # column of decode_op. Since column_order is not provided, both columns "image"
-            >>> # and "label" will be propagated to the child node in their original order.
+            >>> # Apply decode_op on column "image".
             >>> dataset = dataset.map(operations=[decode_op], input_columns=["image"])
             >>>
             >>> # Decode and rename column "image" to "decoded_image".
             >>> dataset = dataset.map(operations=[decode_op], input_columns=["image"], output_columns=["decoded_image"])
             >>>
-            >>> # Specify the order of the output columns.
-            >>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
-            ...                       output_columns=None, column_order=["label", "image"])
-            >>>
-            >>> # Rename column "image" to "decoded_image" and also specify the order of the output columns.
-            >>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
-            ...                       output_columns=["decoded_image"], column_order=["label", "decoded_image"])
-            >>>
-            >>> # Rename column "image" to "decoded_image" and keep only this column.
-            >>> dataset = dataset.map(operations=[decode_op], input_columns=["image"],
-            ...                       output_columns=["decoded_image"], column_order=["decoded_image"])
-            >>>
-            >>> # A simple example for mapping pyfunc. Renaming columns and specifying column order
-            >>> # work in the same way as the previous examples.
+            >>> # A simple example for user defined python function transform.
             >>> dataset = ds.NumpySlicesDataset(data=[[0, 1, 2]], column_names=["data"])
-            >>> dataset = dataset.map(operations=[(lambda x: x + 1)], input_columns=["data"])
+            >>> dataset = dataset.map(operations=[(lambda x: x - 1)], input_columns=["data"])
             >>>
             >>> # 2) Map example with more than one operation.
             >>>
@@ -858,17 +903,14 @@ class Dataset:
             >>> # outputted by decode_op is passed as input to random_jitter_op.
             >>> # random_jitter_op will output one column. Column "image" will be replaced by
             >>> # the column outputted by random_jitter_op (the very last operation). All other
-            >>> # columns are unchanged. Since column_order is not specified, the order of the
-            >>> # columns will remain the same.
+            >>> # columns are unchanged.
             >>> dataset = dataset.map(operations=[decode_op, random_jitter_op], input_columns=["image"])
             >>>
             >>> # Rename the column outputted by random_jitter_op to "image_mapped".
-            >>> # Specifying column order works in the same way as examples in 1).
             >>> dataset = dataset.map(operations=[decode_op, random_jitter_op], input_columns=["image"],
             ...                       output_columns=["image_mapped"])
             >>>
-            >>> # Map with multiple operations using pyfunc. Renaming columns and specifying column order
-            >>> # work in the same way as examples in 1).
+            >>> # Map with multiple operations using pyfunc and rename column's name
             >>> dataset = ds.NumpySlicesDataset(data=[[0, 1, 2]], column_names=["data"])
             >>> dataset = dataset.map(operations=[(lambda x: x * x), (lambda x: x - 1)], input_columns=["data"],
             ...                                   output_columns=["data_mapped"])
@@ -885,22 +927,9 @@ class Dataset:
             >>> operations = [(lambda x, y: (x, x + y, x + y + 1)),
             ...               (lambda x, y, z: x * y * z),
             ...               (lambda x: (x % 2, x % 3, x % 5, x % 7))]
-            >>>
-            >>> # Note: Since the number of input columns is not the same as the number of
-            >>> # output columns, the output_columns and column_order parameters must be
-            >>> # specified. Otherwise, this map call will also result in an error.
-            >>>
             >>> dataset = ds.NumpySlicesDataset(data=([[0, 1, 2]], [[3, 4, 5]]), column_names=["x", "y"])
-            >>>
-            >>> # Propagate all columns to the child node in this order:
-            >>> dataset = dataset.map(operations, input_columns=["x", "y"],
-            ...                       output_columns=["mod2", "mod3", "mod5", "mod7"],
-            ...                       column_order=["mod2", "mod3", "mod5", "mod7"])
-            >>>
-            >>> # Propagate some columns to the child node in this order:
             >>> dataset = dataset.map(operations, input_columns=["x", "y"],
-            ...                       output_columns=["mod2", "mod3", "mod5", "mod7"],
-            ...                       column_order=["mod7", "mod3", "col2"])
+            ...                       output_columns=["mod2", "mod3", "mod5", "mod7"])
         """
         if hasattr(self, 'operator_mixed') and getattr(self, 'operator_mixed') is True:
             num_parallel_workers = 1
@@ -909,8 +938,7 @@ class Dataset:
                 "mindspore.numpy module and etc, which do not support multi-thread compiling, recommend to replace it "
                 "with python implemented operator like numpy etc. Here decrease 'num_parallel_workers' into 1.")
 
-        return MapDataset(self, operations, input_columns, output_columns, column_order, num_parallel_workers,
-                          python_multiprocessing, cache, callbacks, max_rowsize, offload)
+        return MapDataset(self, operations, input_columns, output_columns, num_parallel_workers, **kwargs)
 
     @check_filter
     def filter(self, predicate, input_columns=None, num_parallel_workers=None):
@@ -920,9 +948,9 @@ class Dataset:
         Args:
             predicate (callable): Python callable which returns a boolean value. If False then filter the element.
             input_columns (Union[str, list[str]], optional): List of names of the input columns. If not provided
-                or provided with None, the predicate will be applied on all columns in the dataset (default=None).
+                or provided with None, the predicate will be applied on all columns in the dataset. Default: None.
             num_parallel_workers (int, optional): Number of workers to process the dataset
-                in parallel (default=None).
+                in parallel. Default: None.
 
         Returns:
             Dataset, dataset filtered.
@@ -944,7 +972,7 @@ class Dataset:
             the repeat operation is used after the batch operation.
 
         Args:
-            count (int): Number of times the dataset is going to be repeated (default=None).
+            count (int): Number of times the dataset is going to be repeated. Default: None.
 
         Returns:
             Dataset, dataset repeated.
@@ -960,7 +988,7 @@ class Dataset:
             >>> dataset = dataset.repeat(50)
             >>>
             >>> # Create a dataset where the dataset is first repeated for
-            >>> # 50 epochs before shuffling. The shuffle operator will treat
+            >>> # 50 epochs before shuffling. The shuffle operation will treat
             >>> # the entire 50 epochs as one big dataset.
             >>> dataset = dataset.repeat(50)
             >>> dataset = dataset.shuffle(10)
@@ -997,7 +1025,7 @@ class Dataset:
                then take the given number of rows; otherwise take the given number of batches.
 
         Args:
-            count (int, optional): Number of elements to be taken from the dataset (default=-1).
+            count (int, optional): Number of elements to be taken from the dataset. Default: -1.
 
         Returns:
             Dataset, dataset taken.
@@ -1085,7 +1113,7 @@ class Dataset:
                 - The sum of split sizes > K, the difference of sigma(round(fi * K)) - K will be removed from the first
                   large enough split such that it will have at least 1 row after removing the difference.
 
-            randomize (bool, optional): Determines whether or not to split the data randomly (default=True).
+            randomize (bool, optional): Determines whether or not to split the data randomly. Default: True.
                 If True, the data will be randomly split. Otherwise, each split will be created with
                 consecutive rows from the dataset.
 
@@ -1147,12 +1175,15 @@ class Dataset:
         name.
 
         Args:
-            datasets (Union[tuple, class Dataset]): A tuple of datasets or a single class Dataset
+            datasets (Union[Dataset, tuple[Dataset]]): A tuple of datasets or a single class Dataset
                 to be zipped together with this dataset.
 
         Returns:
             Dataset, dataset zipped.
 
+        Raises:
+            TypeError: The parameter is not dataset object or tuple of dataset objects.
+
         Examples:
             >>> # Create a dataset which is the combination of dataset and dataset_1
             >>> dataset = dataset.zip(dataset_1)
@@ -1249,7 +1280,7 @@ class Dataset:
 
         Args:
             apply_func (function): A function that must take one `Dataset` as an argument and
-                                   return a preprocessed `Dataset`.
+                                   return a preprocessed `Dataset` .
 
         Returns:
             Dataset, dataset applied by the function.
@@ -1284,9 +1315,9 @@ class Dataset:
         Return a transferred Dataset that transfers data through a device.
 
         Args:
-            send_epoch_end (bool, optional): Whether to send end of sequence to device or not (default=True).
+            send_epoch_end (bool, optional): Whether to send end of sequence to device or not. Default: True.
             create_data_info_queue (bool, optional): Whether to create queue which stores
-                types and shapes of data or not(default=False).
+                types and shapes of data or not. Default: False.
 
         Note:
             If device is Ascend, features of data will be transferred one by one. The limitation
@@ -1294,34 +1325,17 @@ class Dataset:
 
         Returns:
             Dataset, dataset for transferring.
-        """
-        return TransferDataset(self, send_epoch_end, create_data_info_queue)
-
-    @check_device_send
-    def to_device(self, send_epoch_end=True, create_data_info_queue=False):
-        """
-        Transfer data from CPU to GPU or Ascend or other devices.
-
-        Args:
-            send_epoch_end (bool, optional): Whether to send the end of sequence to device or not (default=True).
-            create_data_info_queue (bool, optional): Whether to create queue which stores
-                types and shapes of data or not(default=False).
-
-        Note:
-            This interface will be deleted or invisible in the future.
-            Please use `device_que` to enable dataset sink mode.
-            If device is Ascend, features of data will be transferred one by one. The limitation
-            of data transmission per second is 256M.
 
-        Returns:
-            TransferDataset, dataset for transferring.
-
-        Raises:
-            RuntimeError: If distribution file path is given but failed to read.
+        Examples:
+            >>> import time
+            >>>
+            >>> data = ds.TFRecordDataset('/path/to/TF_FILES', '/path/to/TF_SCHEMA_FILE', shuffle=ds.Shuffle.FILES)
+            >>>
+            >>> data = data.device_que()
+            >>> data.send()
+            >>> time.sleep(0.1)
+            >>> data.stop_send()
         """
-        logger.warning("This interface will be deleted or invisible in the future. "
-                       "Please use 'device_que' to enable dataset sink mode.")
-
         return TransferDataset(self, send_epoch_end, create_data_info_queue)
 
     @check_save
@@ -1330,7 +1344,8 @@ class Dataset:
         Save the dynamic data processed by the dataset pipeline in common dataset format.
         Supported dataset formats: `mindrecord` only. And you can use `MindDataset` API to read the saved file(s).
 
-        Implicit type casting exists when saving data as `mindrecord`. The transform table shows how to do type casting.
+        Implicit type casting exists when saving data as `mindrecord` . The transform table shows how to do
+        type casting.
 
         .. list-table:: Implicit Type Casting when Saving as `mindrecord`
            :widths: 25 25 50
@@ -1381,8 +1396,8 @@ class Dataset:
 
         Note:
             1. To save the samples in order, set dataset's shuffle to False and num_files to 1.
-            2. Before calling the function, do not use batch operator, repeat operator or data augmentation operators
-               with random attribute in map operator.
+            2. Before calling the function, do not use batch operation, repeat operation or data augmentation operations
+               with random attribute in map operation.
             3. When array dimension is variable, one-dimensional arrays or
                multi-dimensional arrays with variable dimension 0 are supported.
             4. Mindrecord does not support uint64, multi-dimensional uint8(drop dimension) nor
@@ -1390,9 +1405,20 @@ class Dataset:
 
         Args:
             file_name (str): Path to dataset file.
-            num_files (int, optional): Number of dataset files (default=1).
-            file_type (str, optional): Dataset format (default='mindrecord').
+            num_files (int, optional): Number of dataset files. Default: 1.
+            file_type (str, optional): Dataset format. Default: 'mindrecord'.
 
+        Examples:
+            >>> import numpy as np
+            >>>
+            >>> def generator_1d():
+            ...     for i in range(10):
+            ...         yield (np.array([i]),)
+            >>>
+            >>>
+            >>> # apply dataset operations
+            >>> d1 = ds.GeneratorDataset(generator_1d, ["data"], shuffle=False)
+            >>> d1.save('/path/to/save_file')
         """
         ir_tree, api_tree = self.create_ir_tree()
 
@@ -1409,20 +1435,20 @@ class Dataset:
     @check_tuple_iterator
     def create_tuple_iterator(self, columns=None, num_epochs=-1, output_numpy=False, do_copy=True):
         """
-        Create an iterator over the dataset. The datatype retrieved back will be a list of `numpy.ndarray`.
+        Create an iterator over the dataset. The datatype retrieved back will be a list of `numpy.ndarray` .
 
         To specify which columns to list and the order needed, use columns_list. If columns_list
         is not provided, the order of the columns will remain unchanged.
 
         Args:
-            columns (list[str], optional): List of columns to be used to specify the order of columns
-                (default=None, means all columns).
+            columns (list[str], optional): List of columns to be used to specify the order of columns.
+                Default: None, means all columns.
             num_epochs (int, optional): Maximum number of epochs that iterator can be iterated.
-                (default=-1, iterator can be iterated infinite number of epochs)
+                Default: -1, iterator can be iterated infinite number of epochs.
             output_numpy (bool, optional): Whether or not to output NumPy datatype.
-                If output_numpy=False, iterator will output MSTensor (default=False).
-            do_copy (bool, optional): when output data type is mindspore.Tensor,
-                use this param to select the conversion method, only take False for better performance (default=True).
+                If output_numpy=False, iterator will output MSTensor. Default: False.
+            do_copy (bool, optional): When output data type is mindspore.Tensor,
+                use this param to select the conversion method, only take False for better performance. Default: True.
 
         Returns:
             Iterator, tuple iterator over the dataset.
@@ -1444,15 +1470,17 @@ class Dataset:
         return TupleIterator(self, columns, num_epochs, output_numpy, do_copy)
 
     @check_dict_iterator
-    def create_dict_iterator(self, num_epochs=-1, output_numpy=False):
+    def create_dict_iterator(self, num_epochs=-1, output_numpy=False, do_copy=True):
         """
         Create an iterator over the dataset. The data retrieved will be a dictionary datatype.
 
         Args:
-            num_epochs (int, optional): Maximum number of epochs that iterator can be iterated
-                (default=-1, iterator can be iterated infinite number of epochs).
+            num_epochs (int, optional): Maximum number of epochs that iterator can be iterated.
+                Default: -1, iterator can be iterated infinite number of epochs.
             output_numpy (bool, optional): Whether or not to output NumPy datatype,
-                if output_numpy=False, iterator will output MSTensor (default=False).
+                if output_numpy=False, iterator will output MSTensor. Default: False.
+            do_copy (bool, optional): When output data type is mindspore.Tensor,
+                use this param to select the conversion method, only take False for better performance. Default: True.
 
         Returns:
             Iterator, dictionary iterator over the dataset.
@@ -1471,7 +1499,7 @@ class Dataset:
 
         if Dataset._noop_mode():
             return DummyIterator(self, 'dict', output_numpy)
-        return DictIterator(self, num_epochs, output_numpy)
+        return DictIterator(self, num_epochs, output_numpy, do_copy)
 
     def __iter__(self):
         """Create an iterator over the dataset."""
@@ -1587,11 +1615,6 @@ class Dataset:
         if estimate and self.estimated_output_shapes is not None:
             return self.estimated_output_shapes
 
-        # if use set_dynamic_column, the `estimate` does not work, but they get the same result
-        if self.dynamic_setting[0]:
-            self.saved_output_shapes, self.saved_min_shapes, self.saved_max_shapes = self._dynamic_output_shapes()
-            return self.saved_output_shapes
-
         # We have a hang problem when two-level pipeline with multiprocessing, we need to extend the life cycle
         # of runtime_context. We found this hang problem only occur on output_types and output_shapes.
         runtime_getter = self._init_tree_getters()
@@ -1599,6 +1622,9 @@ class Dataset:
         api_tree = runtime_getter[2]
         output_shapes = runtime_getter[0].GetOutputShapes(estimate)
         del api_tree
+        # Need to terminate the runtime context to avoid the occasional hang problem for
+        # Python (with multiprocessing enabled) in sink mode.
+        self.runtime_context.Terminate()
         del self.runtime_context
 
         if estimate:
@@ -1626,6 +1652,9 @@ class Dataset:
             api_tree = runtime_getter[2]
             self.saved_output_types = runtime_getter[0].GetOutputTypes()
             del api_tree
+            # Need to terminate the runtime context to avoid the occasional hang problem for
+            # Python (with multiprocessing enabled) in sink mode.
+            self.runtime_context.Terminate()
             del self.runtime_context
         return self.saved_output_types
 
@@ -1648,136 +1677,6 @@ class Dataset:
 
         return self.dataset_size
 
-    @deprecated("1.5")
-    def set_dynamic_columns(self, columns=None):
-        """
-        Set dynamic shape information of source data, it should be set after the pipeline is defined.
-
-        Args:
-            columns (dict): A dict contains shape information of each column in dataset.
-                The value of shape[i] is :py:obj:`None` indicates that the data length of shape[i] is dynamic.
-
-        Examples:
-            >>> import numpy as np
-            >>>
-            >>> def generator1():
-            ...     for i in range(1, 100):
-            ...         yield np.ones((16, i, 83)), np.array(i)
-            >>>
-            >>> dataset = ds.GeneratorDataset(generator1, ["data1", "data2"])
-            >>> dataset.set_dynamic_columns(columns={"data1": [16, None, 83], "data2": []})
-        """
-        if not isinstance(columns, dict):
-            raise TypeError("Pass a dict to set dynamic shape, example: {\"data1\": [16, None, 256]}")
-        self.dynamic_setting[0] = True
-        self.dynamic_setting[1] = columns
-
-    def dynamic_min_max_shapes(self):
-        """
-        Get minimum and maximum data length of dynamic source data, for dynamic graph compilation.
-
-        Returns:
-            lists, min_shapes, max_shapes of source data.
-
-        Examples:
-            >>> import numpy as np
-            >>>
-            >>> def generator1():
-            ...     for i in range(1, 100):
-            ...         yield np.ones((16, i, 83)), np.array(i)
-            >>>
-            >>> dataset = ds.GeneratorDataset(generator1, ["data1", "data2"])
-            >>> dataset.set_dynamic_columns(columns={"data1": [16, None, 83], "data2": []})
-            >>> min_shapes, max_shapes = dataset.dynamic_min_max_shapes()
-        """
-        if self.saved_min_shapes is None or self.saved_max_shapes is None:
-            self.saved_output_shapes, self.saved_min_shapes, self.saved_max_shapes = self._dynamic_output_shapes()
-        return self.saved_min_shapes, self.saved_max_shapes
-
-    @staticmethod
-    def __check_dynamic_column_name(dynamic_columns, dataset_columns):
-        for column in dynamic_columns:
-            if column not in dataset_columns:
-                raise RuntimeError("dynamic column [" + column + "] does not match any column in dataset: " +
-                                   str(dataset_columns))
-
-    @staticmethod
-    def __check_dynamic_column_shape(data, col, dynamic_columns):
-        shape_mismatch = "dynamic column [" + col + "] with shape " + str(dynamic_columns[col]) + \
-                         " does not match dataset column [" + col + "] with shape " + str(list(data[col].shape))
-        if data[col].ndim != len(dynamic_columns[col]):
-            raise RuntimeError(shape_mismatch)
-        for dim in range(len(dynamic_columns[col])):
-            if dynamic_columns[col][dim] is not None and dynamic_columns[col][dim] != data[col].shape[dim]:
-                raise RuntimeError(shape_mismatch)
-
-    def _dynamic_output_shapes(self):
-        """
-        Get dynamic information of source data.
-
-        Returns:
-            lists, dynamic_shapes, min_shapes, max_shapes of source data.
-        """
-        if not self.dynamic_setting[1]:
-            raise RuntimeError("dynamic_columns is not set, call set_dynamic_columns() by final Dataset Op.")
-
-        if self.saved_output_shapes is not None and self.saved_min_shapes is not None and \
-                self.saved_max_shapes is not None:
-            return self.saved_output_shapes, self.saved_min_shapes, self.saved_max_shapes
-
-        logger.warning("Calculating dynamic shape of input data, this will take a few minutes...")
-        # Assume data1 shape is dynamic, data2 shape is fix
-        dynamic_columns = self.dynamic_setting[1]
-        # ["data1", "data2"]
-        dataset_columns = self.get_col_names()
-        Dataset.__check_dynamic_column_name(dynamic_columns, dataset_columns)
-
-        # Shape[1] of data1 is variable
-        # {"data1": {(batch_size, 100, feat_len), (16, 200, 83)}, "data2": {(batch_size, feat_len)}}
-        column_shape_set = {col: set() for col in dataset_columns}
-        dataset_size_counter = 0
-        for data in self.create_dict_iterator(num_epochs=1, output_numpy=True):
-            dataset_size_counter += 1
-            for col in data.keys():
-                if col in dynamic_columns:
-                    Dataset.__check_dynamic_column_shape(data, col, dynamic_columns)
-                column_shape_set[col].add(tuple(data[col].shape))
-
-        # we get dataset_size after dryrun
-        self.dataset_size = dataset_size_counter
-
-        min_shapes, max_shapes, dynamic_shapes = list(), list(), list()
-        for col, shape_set in column_shape_set.items():
-            if len(shape_set) > 1:
-                if col not in dynamic_columns:
-                    raise RuntimeError("column [" + col + "] has dynamic shape but not set by set_dynamic_columns()" +
-                                       ", shapes of [" + col + "]: " + str(list(shape_set)))
-                shape_npy = np.array(list(shape_set))
-                max_shape = shape_npy.max(axis=0)
-                min_shape = shape_npy.min(axis=0)
-
-                # Set min shape to 1 due to unknown shuffle
-                min_shape = np.where(np.equal(dynamic_columns[col], None), 1, min_shape)
-                # Set dynamic dim to -1 for ME
-                dynamic_shape = np.where(np.equal(dynamic_columns[col], None), -1, dynamic_columns[col])
-
-                max_shapes.append(max_shape.tolist())
-                min_shapes.append(min_shape.tolist())
-                dynamic_shapes.append(dynamic_shape.tolist())
-            else:
-                # Also append fix shape to keep order of column shape
-                fix_shape = list(list(shape_set)[0])
-                max_shapes.append(fix_shape)
-                min_shapes.append(fix_shape)
-                dynamic_shapes.append(fix_shape)
-                if col in dynamic_columns:
-                    logger.warning("column [" + col + "] has no dynamic shape but set by set_dynamic_columns()")
-                    # Set min shape to 1 due to unknown shuffle
-                    min_shapes[-1] = np.where(np.equal(dynamic_columns[col], None), 1, fix_shape).tolist()
-                    # Set dynamic dim to -1 for ME
-                    dynamic_shapes[-1] = np.where(np.equal(dynamic_columns[col], None), -1, fix_shape).tolist()
-        return dynamic_shapes, min_shapes, max_shapes
-
     def num_classes(self):
         """
         Get the number of classes in a dataset.
@@ -1820,8 +1719,41 @@ class Dataset:
             condition_name (str): The condition name that is used to toggle sending next row.
             num_batch (Union[int, None]): The number of batches (rows) that are released.
                 When num_batch is None, it will default to the number specified by the
-                sync_wait operator (default=None).
-            data (Any): The data passed to the callback, user defined (default=None).
+                sync_wait operation. Default: None.
+            data (Any): The data passed to the callback, user defined. Default: None.
+
+        Examples:
+            >>> import numpy as np
+            >>>
+            >>>
+            >>> def gen():
+            ...     for i in range(100):
+            ...         yield (np.array(i),)
+            >>>
+            >>>
+            >>> class Augment:
+            ...     def __init__(self, loss):
+            ...         self.loss = loss
+            ...
+            ...     def preprocess(self, input_):
+            ...         return input_
+            ...
+            ...     def update(self, data):
+            ...         self.loss = data["loss"]
+            >>>
+            >>>
+            >>> batch_size = 10
+            >>> dataset = ds.GeneratorDataset(gen, column_names=["input"])
+            >>> aug = Augment(0)
+            >>> dataset = dataset.sync_wait(condition_name='', num_batch=1)
+            >>> dataset = dataset.map(input_columns=["input"], operations=[aug.preprocess])
+            >>> dataset = dataset.batch(batch_size)
+            >>>
+            >>> count = 0
+            >>> for data in dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+            ...     count += 1
+            ...     data = {"loss": count}
+            ...     dataset.sync_update(condition_name="", data=data)
         """
         if (not isinstance(num_batch, int) and num_batch is not None) or \
                 (isinstance(num_batch, int) and num_batch <= 0):
@@ -1845,7 +1777,7 @@ class Dataset:
         Return the size of batch.
 
         Returns:
-            int, the number of data in a batch.
+            int, the batch size of data.
 
         Examples:
             >>> # dataset is an instance object of Dataset
@@ -1860,7 +1792,7 @@ class Dataset:
 
     def get_repeat_count(self):
         """
-        Get the replication times in RepeatDataset (default is 1).
+        Get the replication times in RepeatDataset. Default: 1.
 
         Returns:
             int, the count of repeat.
@@ -1894,7 +1826,18 @@ class Dataset:
         return {}
 
     def reset(self):
-        """Reset the dataset for next epoch."""
+        """
+        Reset the dataset for next epoch.
+
+        Examples:
+            >>> mind_dataset_dir = ["/path/to/mind_dataset_file"]
+            >>> dataset = ds.MindDataset(dataset_files=mind_dataset_dir)
+            >>> for _ in range(5):
+            ...     num_iter = 0
+            ...     for data in dataset.create_tuple_iterator(num_epochs=1, output_numpy=True):
+            ...         num_iter += 1
+            ...     dataset.reset()
+        """
 
     def is_shuffled(self):
         """Returns True if the dataset or its children is shuffled."""
@@ -1915,6 +1858,15 @@ class Dataset:
     def parse(self, children=None):
         raise NotImplementedError("Dataset has to implement parse method.")
 
+    def __len__(self):
+        """
+        Get the length of dataset.
+
+        Returns:
+            int, the length of dataset.
+        """
+        return self.get_dataset_size()
+
     @staticmethod
     def _update_data_shard(num_shards, shard_id):
         """
@@ -1970,6 +1922,10 @@ class TextBaseDataset(Dataset):
         Build a vocab from a dataset. This would collect all the unique words in a dataset and return a vocab
         which contains top_k most frequent words (if top_k is specified).
 
+        Note:
+            mindspore.dataset.Dataset.build_vocab is deprecated from version 2.0
+            and will be removed in a future version. Use mindspore.dataset.text.Vocab.from_dataset instead.
+
         Args:
             columns(Union[str, list[str]]): Column names to get words from.
             freq_range(tuple[int]): A tuple of integers (min_frequency, max_frequency). Words within the frequency
@@ -1984,22 +1940,60 @@ class TextBaseDataset(Dataset):
 
         Returns:
             Vocab, vocab built from the dataset.
+        """
+        warnings.warn("mindspore.dataset.Dataset.build_vocab is deprecated from version 2.0 "
+                      "and will be removed in a future version. "
+                      "Use mindspore.dataset.text.Vocab.from_dataset instead.", DeprecationWarning)
 
-        Examples:
-            >>> import numpy as np
-            >>>
-            >>> def gen_corpus():
-            ...     # key: word, value: number of occurrences, reason for using letters is so their order is apparent
-            ...     corpus = {"Z": 4, "Y": 4, "X": 4, "W": 3, "U": 3, "V": 2, "T": 1}
-            ...     for k, v in corpus.items():
-            ...         yield (np.array([k] * v, dtype='S'),)
-            >>> column_names = ["column1"]
-            >>> dataset = ds.GeneratorDataset(gen_corpus, column_names)
-            >>> dataset = dataset.build_vocab(columns=["column1"],
-            ...                               freq_range=(1, 10), top_k=5,
-            ...                               special_tokens=["<pad>", "<unk>"],
-            ...                               special_first=True)
+    def build_sentencepiece_vocab(self, columns, vocab_size, character_coverage, model_type, params):
+        """
+        Function to create a SentencePieceVocab from source dataset.
+        Desired source dataset is a text type dataset.
+
+        Note:
+            mindspore.dataset.Dataset.build_sentencepiece_vocab is deprecated from version 2.0
+            and will be removed in a future version. Use mindspore.dataset.text.SentencePieceVocab.from_dataset instead.
+
+        Args:
+            columns(list[str]): Column names to get words from.
+            vocab_size(int): Vocabulary size.
+            character_coverage(float): Percentage of characters covered by the model, must be between
+                0.98 and 1.0 Good defaults are: 0.9995 for languages with rich character sets like
+                Japanese or Chinese character sets, and 1.0 for other languages with small character sets
+                like English or Latin.
+            model_type(SentencePieceModel): Model type. Choose from unigram (default), bpe, char, or word.
+                The input sentence must be pretokenized when using word type.
+            params(dict): Any extra optional parameters of sentencepiece library according to your raw data
+
+        Returns:
+            SentencePieceVocab, vocab built from the dataset.
+        """
+        warnings.warn("mindspore.dataset.Dataset.build_vocab is deprecated from version 2.0 "
+                      "and will be removed in a future version. "
+                      "Use mindspore.dataset.text.Vocab.from_dataset instead.", DeprecationWarning)
 
+    def _build_vocab(self, columns, freq_range, top_k, special_tokens, special_first):
+        """
+        Function to create a Vocab from source dataset.
+        Desired source dataset is a text type dataset.
+
+        Build a vocab from a dataset. This would collect all the unique words in a dataset and return a vocab
+        which contains top_k most frequent words (if top_k is specified).
+
+        Args:
+            columns(Union[str, list[str]]): Column names to get words from.
+            freq_range(tuple[int]): A tuple of integers (min_frequency, max_frequency). Words within the frequency
+                range will be stored.
+                Naturally 0 <= min_frequency <= max_frequency <= total_words. min_frequency/max_frequency
+                can be set to default, which corresponds to 0/total_words separately.
+            top_k(int): Number of words to be built into vocab. top_k most frequent words are
+                taken. The top_k is taken after freq_range. If not enough top_k, all words will be taken
+            special_tokens(list[str]): A list of strings, each one is a special token.
+            special_first(bool): Whether special_tokens will be prepended/appended to vocab, If special_tokens
+                is specified and special_first is set to default, special_tokens will be prepended.
+
+        Returns:
+            Vocab, vocab built from the dataset.
         """
         vocab = cde.Vocab()
         columns = replace_none(columns, [])
@@ -2032,7 +2026,7 @@ class TextBaseDataset(Dataset):
 
         return vocab
 
-    def build_sentencepiece_vocab(self, columns, vocab_size, character_coverage, model_type, params):
+    def _build_sentencepiece_vocab(self, columns, vocab_size, character_coverage, model_type, params):
         """
         Function to create a SentencePieceVocab from source dataset.
         Desired source dataset is a text type dataset.
@@ -2050,13 +2044,6 @@ class TextBaseDataset(Dataset):
 
         Returns:
             SentencePieceVocab, vocab built from the dataset.
-
-        Examples:
-            >>> from mindspore.dataset.text import SentencePieceModel
-            >>>
-            >>> # You can construct any text dataset as source, take TextFileDataset as example.
-            >>> dataset = ds.TextFileDataset("/path/to/sentence/piece/vocab/file", shuffle=False)
-            >>> dataset = dataset.build_sentencepiece_vocab(["text"], 5000, 0.9995, SentencePieceModel.UNIGRAM, {})
         """
         if not isinstance(model_type, SentencePieceModel):
             raise TypeError("Argument model_type with value {0} is not of type SentencePieceModel, but got {1}." \
@@ -2264,7 +2251,7 @@ class MappableDataset(SourceDataset):
                 - The sum of split sizes > K, the difference will be removed from the first large
                   enough split such that it will have at least 1 row after removing the difference.
 
-            randomize (bool, optional): Determines whether or not to split the data randomly (default=True).
+            randomize (bool, optional): Determines whether or not to split the data randomly. Default: True.
                 If True, the data will be randomly split. Otherwise, each split will be created with
                 consecutive rows from the dataset.
 
@@ -2340,7 +2327,7 @@ class MappableDataset(SourceDataset):
 
 class BucketBatchByLengthDataset(UnionBaseDataset):
     """
-    The result of applying BucketBatchByLength operator to the input dataset.
+    The result of applying BucketBatchByLength operation to the input dataset.
     """
 
     def __init__(self, input_dataset, column_names, bucket_boundaries, bucket_batch_sizes, element_length_function,
@@ -2391,17 +2378,17 @@ def _check_shm_usage(num_worker, queue_size, max_rowsize, num_queues=1):
 
 class BatchDataset(UnionBaseDataset):
     """
-    The result of applying Batch operator to the input dataset.
+    The result of applying Batch operation to the input dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to be batched.
         batch_size (Union[int, function]): The number of rows each batch is created with. An
             int or callable which takes exactly 1 parameter, BatchInfo.
         drop_remainder (bool, optional): Determines whether or not to drop the last
-            possibly incomplete batch (default=False). If True, and if there are less
+            possibly incomplete batch. Default: False. If True, and if there are less
             than batch_size rows available to make the last batch, then those rows will
             be dropped and not propagated to the child node.
-        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel (default=None).
+        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel. Default: None.
         per_batch_map (callable, optional): Per batch map callable. A callable which takes
             (list[Tensor], list[Tensor], ..., BatchInfo) as input parameters. Each list[Tensor] represents a batch of
             Tensors on a given column. The number of lists should match with number of entries in input_columns. The
@@ -2411,21 +2398,15 @@ class BatchDataset(UnionBaseDataset):
         output_columns (Union[str, list[str]], optional): List of names assigned to the columns outputted by
             the last operation. This parameter is mandatory if len(input_columns) !=
             len(output_columns). The size of this list must match the number of output
-            columns of the last operation. (default=None, output columns will have the same
-            name as the input columns, i.e., the columns will be replaced).
-        column_order (Union[str, list[str]], optional): Specifies the list of all the columns you need in the whole
-                dataset. The parameter is required when len(input_column) != len(output_column). Caution: the list here
-                is not just the columns specified in parameter input_columns and output_columns.
-        pad_info (dict, optional): Whether to perform padding on selected columns. pad_info={"col1":([224,224],0)}
-            will pad column with name "col1" to a tensor of size [224,224] and fill the missing with 0.
+            columns of the last operation. Default: None, output columns will have the same
+            name as the input columns, i.e., the columns will be replaced.
         max_rowsize(int, optional): Maximum size of row in MB that is used for shared memory allocation to copy
-            data between processes.  This is only used if python_multiprocessing is set to True (default=16).
+            data between processes.  This is only used if python_multiprocessing is set to True. Default: 16.
 
     """
 
     def __init__(self, input_dataset, batch_size, drop_remainder=False, num_parallel_workers=None, per_batch_map=None,
-                 input_columns=None, output_columns=None, column_order=None, pad_info=None,
-                 python_multiprocessing=False, max_rowsize=16):
+                 input_columns=None, output_columns=None, python_multiprocessing=False, max_rowsize=16):
         super().__init__(children=input_dataset, num_parallel_workers=num_parallel_workers)
 
         if BatchDataset._is_ancestor_of_repeat(input_dataset):
@@ -2443,10 +2424,6 @@ class BatchDataset(UnionBaseDataset):
 
         self.input_columns = to_list(input_columns)
         self.output_columns = to_list(output_columns)
-        self.column_order = to_list(column_order)
-
-        self.pad = bool(pad_info is not None)
-        self.pad_info = replace_none(pad_info, dict())
 
         self.python_multiprocessing = python_multiprocessing
         self.process_pool = None
@@ -2458,9 +2435,9 @@ class BatchDataset(UnionBaseDataset):
             del self.process_pool
 
     def parse(self, children=None):
-        return cde.BatchNode(children[0], self.batch_size, self.drop_remainder, self.pad, self.input_columns,
-                             self.output_columns, self.column_order, self.batch_size_func, self.per_batch_map,
-                             self.pad_info, self.process_pool)
+        return cde.BatchNode(children[0], self.batch_size, self.drop_remainder, False, self.input_columns,
+                             self.output_columns, self.batch_size_func, self.per_batch_map, {},
+                             self.process_pool)
 
     @staticmethod
     def _is_ancestor_of_repeat(dataset):
@@ -2506,6 +2483,10 @@ class BatchDataset(UnionBaseDataset):
         """
         if self.python_multiprocessing and platform.system().lower() == 'windows':
             logger.warning("Python multiprocessing is not supported on Windows platform.")
+        if self.python_multiprocessing and get_debug_mode():
+            logger.warning("Python multiprocessing is not supported in debug mode."
+                           " Ignoring Python multiprocessing for batch operation.")
+            self.python_multiprocessing = False
         if self.python_multiprocessing and platform.system().lower() != 'windows':
             if self.per_batch_map is None:
                 logger.warning("per_batch_map is None so python_multiprocessing is ignored for batch.")
@@ -2526,7 +2507,7 @@ class BatchDataset(UnionBaseDataset):
 
 class BatchInfo(cde.CBatchInfo):
     """
-    Only the batch size function and per_batch_map of the batch operator can dynamically adjust parameters
+    Only the batch size function and per_batch_map of the batch operation can dynamically adjust parameters
     based on the number of batches and epochs during training.
     """
 
@@ -2549,7 +2530,7 @@ class BlockReleasePair:
 
     Args:
         init_release_rows (int): Number of lines to allow through the pipeline.
-        callback (function): The callback function that will be called when release is called (default=None).
+        callback (function): The callback function that will be called when release is called. Default: None.
     """
 
     def __init__(self, init_release_rows, callback=None):
@@ -2612,6 +2593,80 @@ class BlockReleasePair:
             self.cv.notify_all()
 
 
+class PaddedBatchDataset(UnionBaseDataset):
+    """
+    The result of applying Batch operation to the input dataset.
+
+    Args:
+        input_dataset (Dataset): Input Dataset to be batched.
+        batch_size (Union[int, function]): The number of rows each batch is created with. An
+            int or callable which takes exactly 1 parameter, BatchInfo.
+        drop_remainder (bool, optional): Determines whether or not to drop the last
+            possibly incomplete batch. Default: False. If True, and if there are less
+            than batch_size rows available to make the last batch, then those rows will
+            be dropped and not propagated to the child node.
+        num_parallel_workers (int, optional): Number of workers to process the dataset in parallel. Default: None.
+        pad_info (dict, optional): Whether to perform padding on selected columns. pad_info={"col1":([224,224],0)}
+            will pad column with name "col1" to a tensor of size [224,224] and fill the missing with 0.
+    """
+
+    def __init__(self, input_dataset, batch_size, drop_remainder=False, num_parallel_workers=None, pad_info=None):
+        super().__init__(children=input_dataset, num_parallel_workers=num_parallel_workers)
+
+        if PaddedBatchDataset._is_ancestor_of_repeat(input_dataset):
+            logger.warning("Repeat is located before padded_batch, data from two epochs can be batched together.")
+
+        PaddedBatchDataset._update_batch_size_for_syncwait(input_dataset, batch_size)
+
+        # if batch_size is callable, set batch_size to 1 and batch_size_func to that callable function
+        self.batch_size = batch_size if not callable(batch_size) else 1
+        self.batch_size_func = None if not callable(batch_size) else batch_size
+
+        self.drop_remainder = replace_none(drop_remainder, False)
+
+        self.pad = bool(pad_info is not None)
+        self.pad_info = replace_none(pad_info, dict())
+
+    def parse(self, children=None):
+        return cde.BatchNode(children[0], self.batch_size, self.drop_remainder, self.pad, [],
+                             [], self.batch_size_func, None, self.pad_info, None)
+
+    @staticmethod
+    def _is_ancestor_of_repeat(dataset):
+        """
+        Utility function to find the case where repeat is used before batch.
+
+        Args:
+             dataset (Dataset): Dataset to be checked.
+
+        Returns:
+            bool, whether repeat is used before batch.
+        """
+        if isinstance(dataset, RepeatDataset):
+            return True
+        flag = False
+        for input_dataset in dataset.children:
+            flag = flag | PaddedBatchDataset._is_ancestor_of_repeat(input_dataset)
+        return flag
+
+    @staticmethod
+    def _update_batch_size_for_syncwait(dataset, batch_size):
+        """
+        Utility function to notify batch size to sync_wait.
+
+        Args:
+             dataset (Dataset): Dataset to be checked.
+             batch_size (int): batch size to notify.
+        """
+        if isinstance(dataset, SyncWaitDataset):
+            dataset.update_sync_batch_size(batch_size)
+        for input_dataset in dataset.children:
+            PaddedBatchDataset._update_batch_size_for_syncwait(input_dataset, batch_size)
+
+    def __deepcopy__(self, memodict):
+        return self.__safe_deepcopy__(memodict, exclude=("batch_size_func", "__transfer_dataset__"))
+
+
 class SyncWaitDataset(UnionBaseDataset):
     """
     The result of adding a blocking condition to the input Dataset.
@@ -2620,7 +2675,7 @@ class SyncWaitDataset(UnionBaseDataset):
         input_dataset (Dataset): Input dataset to apply flow control.
         num_batch (int): Number of batches without blocking at the start of each epoch.
         condition_name (str): Condition name that is used to toggle sending next row.
-        callback (function): Callback function that will be invoked when sync_update is called (default=None).
+        callback (function): Callback function that will be invoked when sync_update is called. Default: None.
 
     Raises:
         RuntimeError: If condition name already exists.
@@ -2670,7 +2725,7 @@ class SyncWaitDataset(UnionBaseDataset):
         Returns:
             bool, whether sync_wait is used before batch.
         """
-        if isinstance(dataset, BatchDataset):
+        if isinstance(dataset, (BatchDataset, PaddedBatchDataset)):
             return True
         flag = False
         for input_dataset in dataset.children:
@@ -2683,14 +2738,14 @@ class SyncWaitDataset(UnionBaseDataset):
 
 class ShuffleDataset(UnionBaseDataset):
     """
-    The result of applying Shuffle operator to the input Dataset.
+    The result of applying Shuffle operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to be shuffled.
         buffer_size (int): Size of the buffer.
 
     Raises:
-        RuntimeError: If exist sync operators before shuffle.
+        RuntimeError: If exist sync operations before shuffle.
     """
 
     def __init__(self, input_dataset, buffer_size):
@@ -2727,17 +2782,38 @@ class _PythonCallable:
         self.pool = pool
         # Python callable index
         self.idx = idx
+        self.check_interval = get_multiprocessing_timeout_interval()
 
     def __call__(self, *args):
         result = None
-        if self.pool.is_running() and check_iterator_cleanup() is False:
-            try:
-                result = self.pool.execute(self.idx, *args)
-            except multiprocessing.TimeoutError:
-                pass
-        if result is None:
-            # Invoke original Python callable in master process in case the pool is gone.
-            result = self.py_callable(*args)
+        start_time = time.time()
+        count = 1
+        get_data_from_worker_process = False
+        while get_data_from_worker_process is False:
+            cost_time = time.time() - start_time
+            if cost_time > (self.check_interval * count):
+                logger.warning("It has been waiting for " + str(cost_time) + "s because the multi "
+                               "workers of map operation cost long time to process next data. "
+                               "Worker process list are: " + str(self.pool.get_pids()) + ", you can use "
+                               "\"py-spy dump -p {PID} -l -s \""
+                               "to dump the worker process stack. You can also set the timeout interval by "
+                               "ds.config.set_multiprocessing_interval to adjust the output frequency of this "
+                               "log.")
+                count += 1
+            if self.pool.is_running() and check_iterator_cleanup() is False:
+                try:
+                    result = self.pool.execute(self.idx, *args)
+                except multiprocessing.TimeoutError:
+                    continue
+                get_data_from_worker_process = True
+            else:
+                # worker process is stopped
+                logger.info("The worker process of map operation is stopped. "
+                            "So return None to main thread and break the main thread.")
+                return None
+        # got value from worker process
+        if not isinstance(result, tuple) and get_data_from_worker_process is True:
+            result = (result,)
         return result
 
     def to_json(self):
@@ -2833,7 +2909,7 @@ def _worker_loop(operations, pipe, seed=get_seed()):
             pipe.worker_send(output_tensors)
         except Exception:
             pipe.worker_send(ExceptionHandler(where="in map(or batch) worker and execute Python function"))
-            return
+            # Do not return
 
 
 def worker_target(operations, seed=get_seed()):
@@ -2922,7 +2998,8 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
         self.ppid = os.getpid()
         self.hook = None
         self.warning_ctl = None
-        self.threads_to_workers = {}
+        # cache thread (get_ident()) to worker_id mapping in Python layer
+        self.python_threads_to_workers = {}
 
     def __del__(self):
         try:
@@ -3067,13 +3144,24 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
         os.kill(os.getpid(), signal.SIGTERM)
 
     def launch(self, op_id=-1):
+        """
+        Launch Python multiprocessing pool.
+
+        Args:
+            pop_id: ID for operation to have Python multiprocessing pool launched
+
+        Returns:
+            Python multiprocssing pool is launched.
+        """
+        self.python_threads_to_workers = {}
         self.op_id = op_id
         logger.info("Launching new Python Multiprocessing pool for Op:" + str(self.op_id))
         if self.is_mp_enabled():
-            logger.warning('Launching a new Python multiprocessing pool while a pool already exists! \
-                The existing pool will be terminated first.')
+            message = "Launching a new Python multiprocessing pool while a pool already exists!" + \
+                " The existing pool will be terminated first."
+            logger.warning(message)
             self.terminate()
-        self.threads_to_workers = {}
+            self.reset()
         self.create_pool()
 
     def create_pool(self):
@@ -3109,7 +3197,6 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
         atexit.register(self.terminate)
 
     def terminate(self):
-        logger.info("Terminating Python Multiprocessing for Op:" + str(self.op_id))
         self.close_all_workers()
         self.abort_watchdog()
 
@@ -3166,7 +3253,10 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
         Execute
         """
         t_id = threading.get_ident()
-        worker_id = self.threads_to_workers.setdefault(t_id, len(self.threads_to_workers))
+        # get the worker_id from Python layer cache first, get from Cpp layer if not found.
+        worker_id = self.python_threads_to_workers.setdefault(t_id, self.get_thread_to_worker())
+        if worker_id >= len(self.workers):
+            raise RuntimeError("[Internal] worker_id value is greater than number of available workers!")
 
         # todo check_iterator_cleanup
         if self.is_running() and check_iterator_cleanup() is False:
@@ -3220,38 +3310,32 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
 
 class MapDataset(UnionBaseDataset):
     """
-    The result of applying the Map operator to the input Dataset.
+    The result of applying the Map operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to be mapped.
         operations (Union[list[TensorOperation], list[functions]]): A function mapping a nested structure of tensors
-            to another nested structure of tensor (default=None).
-        input_columns (Union[str, list[str]]): List of names of the input columns
-            (default=None, the operations will be applied on the first columns in the dataset).
-            The size of the list should match the number of inputs of the first operator.
+            to another nested structure of tensor. Default: None.
+        input_columns (Union[str, list[str]]): List of names of the input columns.
+            Default: None, the operations will be applied on the first columns in the dataset.
+            The size of the list should match the number of inputs of the first operation.
         output_columns (Union[str, list[str]], optional): List of names of the output columns.
-            The size of the list should match the number of outputs of the last operator
-            (default=None, output columns will be the input columns, i.e., the columns will
-            be replaced).
-        column_order (list[str], optional): Specifies the list of all the columns you need in the whole
-            dataset. The parameter is required when len(input_column) != len(output_column). Caution: the list here
-            is not just the columns specified in parameter input_columns and output_columns.
+            The size of the list should match the number of outputs of the last operation.
+            Default: None, output columns will be the input columns, i.e., the columns will
+            be replaced.
         num_parallel_workers (int, optional): Number of workers to process the dataset
-            in parallel (default=None).
+            in parallel. Default: None.
         python_multiprocessing (bool, optional): Parallelize Python operations with multiple worker process. This
-            option could be beneficial if the Python operation is computational heavy (default=False).
+            option could be beneficial if the Python operation is computational heavy. Default: False.
         cache (DatasetCache, optional): Use tensor caching service to speed up dataset processing.
-            (default=None, which means no cache is used).
-        callbacks (DSCallback, list[DSCallback], optional): List of Dataset callbacks to be called (Default=None)
+            Default: None, which means no cache is used.
+        callbacks (DSCallback, list[DSCallback], optional): List of Dataset callbacks to be called. Default: None.
         max_rowsize(int, optional): Maximum size of row in MB that is used for shared memory allocation to copy
-            data between processes.  This is only used if python_multiprocessing is set to True (default=16).
-        offload (bool, optional): Flag to indicate whether offload is used (Default=None).
-
-    Raises:
-        ValueError: If len(input_columns) != len(output_columns) and column_order is not specified.
+            data between processes. This is only used if python_multiprocessing is set to True. Default: 16.
+        offload (bool, optional): Flag to indicate whether offload is used. Default: None.
     """
 
-    def __init__(self, input_dataset, operations=None, input_columns=None, output_columns=None, column_order=None,
+    def __init__(self, input_dataset, operations=None, input_columns=None, output_columns=None,
                  num_parallel_workers=None, python_multiprocessing=False, cache=None, callbacks=None, max_rowsize=16,
                  offload=None):
         super().__init__(children=input_dataset, num_parallel_workers=num_parallel_workers, cache=cache)
@@ -3270,17 +3354,10 @@ class MapDataset(UnionBaseDataset):
 
         self.input_columns = to_list(input_columns)
         self.output_columns = to_list(output_columns)
-        self.column_order = replace_none(column_order, [])
 
         #  If output_columns were not provided then use input_columns
         self.output_columns = self.input_columns if not self.output_columns else self.output_columns
 
-        if self.input_columns and self.output_columns \
-                and len(self.input_columns) != len(self.output_columns) \
-                and not self.column_order:
-            raise ValueError("When length of input_columns and output_columns are not equal,"
-                             " column_order must be specified.")
-
         self.python_multiprocessing = python_multiprocessing
         self.process_pool = None
 
@@ -3297,14 +3374,23 @@ class MapDataset(UnionBaseDataset):
         if count_new_transforms + count_pyfunc == len(operations):
             prev_op = None
             for op in operations:
+                # skip user added DebugHook to avoid changing to Py-implementation.
+                if self.__is_debug_hook_op(op):
+                    if prev_op:
+                        # manually set previous_op_name
+                        prev_op_name = self.__parse_op_name(prev_op)
+                        op.set_previous_op_name(prev_op_name)
+                    continue
                 if op.implementation is None:
                     if prev_op and prev_op.implementation == Implementation.PY:
                         op.implementation = Implementation.PY
                     else:
                         op.implementation = Implementation.C
                 prev_op = op
+            operations = self.__insert_debug_wrapper(operations)
             operations = transforms.transforms.Compose.reduce(operations)
         elif count_old_transforms + count_pyfunc + count_non_data_vision_transforms == len(operations):
+            operations = self.__insert_debug_wrapper(operations)
             operations = transforms.py_transforms.Compose.reduce(operations)
         else:
             raise RuntimeError("Mixing old legacy c/py_transforms and new unified transforms is not allowed.")
@@ -3313,7 +3399,7 @@ class MapDataset(UnionBaseDataset):
         self.prepare_multiprocessing()
 
         callbacks = [cb.create_runtime_obj() for cb in self.callbacks]
-        return cde.MapNode(children[0], self.operations, self.input_columns, self.output_columns, self.column_order,
+        return cde.MapNode(children[0], self.operations, self.input_columns, self.output_columns,
                            callbacks, self.max_rowsize, OffloadToManualOffloadMode.get(self.offload), self.process_pool)
 
     def __deepcopy__(self, memodict):
@@ -3324,6 +3410,49 @@ class MapDataset(UnionBaseDataset):
             self.process_pool.terminate()
             del self.process_pool
 
+    @staticmethod
+    def __parse_op_name(op):
+        """
+        Utility method to get operation name.
+        """
+        op_name = ""
+        if isinstance(op, transforms.py_transforms_util.FuncWrapper):
+            try:
+                op_name = op.transform.__name__
+            except (AttributeError,):
+                op_name = op.transform.__class__.__name__
+        else:
+            op_name = op.__class__.__name__
+        return op_name
+
+    @staticmethod
+    def __construct_debug_hook(previous_op_name=None):
+        """
+        Wrap debug hook into FuncWrapper.
+        """
+        inserted_functions = []
+        debug_hook_list = _get_debug_hook_list()
+        if debug_hook_list:
+            for fn in debug_hook_list:
+                # making deep copy to allow each debug hook instance hold unique variables
+                new_fn = copy.deepcopy(fn)
+                new_fn.set_previous_op_name(previous_op_name)
+                inserted_func = transforms.py_transforms_util.FuncWrapper(new_fn)
+                inserted_func.implementation = Implementation.PY
+                inserted_functions.append(inserted_func)
+        return inserted_functions
+
+    @staticmethod
+    def __is_debug_hook_op(op):
+        """
+        Check if the op is user added DebugHook and skip it to avoid changing transforms implementation.
+        """
+        if isinstance(op, DebugHook):
+            if not get_debug_mode():
+                raise ValueError("It is not allowed to inject DebugHook object in non-debug mode.")
+            return True
+        return False
+
     @staticmethod
     def __count_pyfuncs(operations):
         """
@@ -3389,6 +3518,10 @@ class MapDataset(UnionBaseDataset):
         if self.python_multiprocessing and platform.system().lower() == 'windows':
             logger.warning("Python multiprocessing is not supported on Windows platform.")
             return
+        if self.python_multiprocessing and get_debug_mode():
+            logger.warning("Python multiprocessing is not supported in debug mode."
+                           " Ignoring Python multiprocessing for map operation.")
+            return
         if self.python_multiprocessing:
             iter_specific_operations = []
             callable_list = []
@@ -3419,6 +3552,19 @@ class MapDataset(UnionBaseDataset):
                         iter_specific_operations.append(op)
                 self.operations = iter_specific_operations
 
+    def __insert_debug_wrapper(self, operations):
+        """
+        Insert DebuggerWrapper before and after each op if debug mode is on.
+        """
+        if not get_debug_mode():
+            return operations
+        inserted_operations = self.__construct_debug_hook()
+        for op in operations:
+            inserted_operations.append(op)
+            op_name = self.__parse_op_name(op)
+            inserted_operations.extend(self.__construct_debug_hook(op_name))
+        return inserted_operations
+
     def __decompose_callable_operations(self):
         """
         Decompose operations and build list of old legacy ops which are callable
@@ -3441,10 +3587,10 @@ class FilterDataset(UnionBaseDataset):
     Args:
         input_dataset (Dataset): Input Dataset to be mapped.
         predicate (callable): Python callable which returns a boolean value. If False then filter the element.
-        input_columns (Union[str, list[str]], optional): List of names of the input columns
-        (default=None, the predicate will be applied to all columns in the dataset).
+        input_columns (Union[str, list[str]], optional): List of names of the input columns.
+            Default: None, the predicate will be applied to all columns in the dataset.
         num_parallel_workers (int, optional): Number of workers to process the dataset
-            in parallel (default=None).
+            in parallel. Default: None.
     """
 
     def __init__(self, input_dataset, predicate, input_columns=None, num_parallel_workers=None):
@@ -3458,11 +3604,11 @@ class FilterDataset(UnionBaseDataset):
 
 class RepeatDataset(UnionBaseDataset):
     """
-    The result of applying Repeat operator to the input Dataset.
+    The result of applying Repeat operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to be repeated.
-        count (int): Number of times the dataset will be repeated (default=-1, repeat indefinitely).
+        count (int): Number of times the dataset will be repeated. Default: -1, repeat indefinitely.
     """
 
     def __init__(self, input_dataset, count):
@@ -3475,7 +3621,7 @@ class RepeatDataset(UnionBaseDataset):
 
 class SkipDataset(UnionBaseDataset):
     """
-    The result of applying Skip operator to the input Dataset.
+    The result of applying Skip operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input dataset to have elements skipped.
@@ -3492,7 +3638,7 @@ class SkipDataset(UnionBaseDataset):
 
 class TakeDataset(UnionBaseDataset):
     """
-    The result of applying Take operator to the input Dataset.
+    The result of applying Take operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to have elements taken from.
@@ -3509,7 +3655,7 @@ class TakeDataset(UnionBaseDataset):
 
 class ZipDataset(UnionBaseDataset):
     """
-    The result of applying Zip operator to the input Dataset.
+    The result of applying Zip operation to the input Dataset.
 
     Args:
         datasets (tuple): A tuple of datasets to be zipped together.
@@ -3530,7 +3676,7 @@ class ZipDataset(UnionBaseDataset):
 
 class ConcatDataset(UnionBaseDataset):
     """
-    The result of applying concat dataset operator to the input Dataset.
+    The result of applying Concat operation to the input Dataset.
 
     Args:
         datasets (list): A list of datasets to be concatenated together.
@@ -3615,8 +3761,8 @@ class ConcatDataset(UnionBaseDataset):
             if hasattr(child, 'sampler') and child.sampler.get_num_samples() is not None:
                 raise ValueError("The parameter NumSamples of %s is not support to be set!" % child)
 
-            if isinstance(child, BatchDataset):
-                raise TypeError("The parameter %s of concat must not be BatchDataset!" % child)
+            if isinstance(child, (BatchDataset, PaddedBatchDataset)):
+                raise TypeError("The parameter %s of concat must not be BatchDataset or PaddedBatchDataset!" % child)
 
             # if child is mappable and the length is greater than 0
             if not self._children_flag_and_nums[index][0] and self._children_flag_and_nums[index][1]:
@@ -3641,7 +3787,7 @@ class ConcatDataset(UnionBaseDataset):
 
 class RenameDataset(UnionBaseDataset):
     """
-    The result of applying Rename operator to the input Dataset.
+    The result of applying Rename operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to be Renamed.
@@ -3670,7 +3816,7 @@ def to_list(items):
 
 class ProjectDataset(UnionBaseDataset):
     """
-    The result of applying Project operator to the input Dataset.
+    The result of applying Project operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to be Projected.
@@ -3691,6 +3837,9 @@ class _ToDevice:
     """
 
     def __init__(self, dataset, num_epochs):
+        if get_debug_mode():
+            logger.error("MindData debugger cannot be used in dataset sink mode. Please manually turn off "
+                         "sink mode and try debugger again.")
         ir_tree, self.api_tree = dataset.create_ir_tree()
 
         self._runtime_context = cde.PythonRuntimeContext()
@@ -3705,9 +3854,6 @@ class _ToDevice:
     def send(self):
         self._to_device.Send()
 
-    def _reset(self, step):
-        self._to_device.Reset(step)
-
     def stop_send(self):
         """
         send stop send signal to pipeline, it is used when end of sequence is sent at the epoch end.
@@ -3746,16 +3892,19 @@ class _ToDevice:
         offload_model = GetOffloadModel(self._to_device, col_names)
         return offload_model
 
+    def _reset(self, step, epoch):
+        self._to_device.Reset(step, epoch)
+
 
 class TransferDataset(Dataset):
     """
-    The result of applying TDT operator to the input Dataset.
+    The result of applying TDT operation to the input Dataset.
 
     Args:
         input_dataset (Dataset): Input Dataset to be transferred.
-        send_epoch_end (bool, optional): Whether to send end of sequence to device or not (default=True).
+        send_epoch_end (bool, optional): Whether to send end of sequence to device or not. Default: True.
         create_data_info_queue (bool, optional): Whether to create queue which stores
-            types and shapes of data or not (default=False).
+            types and shapes of data or not. Default: False.
 
     Raises:
         TypeError: If device_type is empty.
@@ -3816,11 +3965,6 @@ class TransferDataset(Dataset):
         if self._to_device is not None:
             self._to_device.continue_send()
 
-    def _reset(self, step):
-        if self._to_device is not None:
-            logger.info("Reset the dataset pipeline to step " + str(step))
-            self._to_device._reset(step)  # pylint: disable=W0212
-
     def get_data_info(self):
         """
         Get type and shape of current batch
@@ -3842,13 +3986,18 @@ class TransferDataset(Dataset):
         if self._to_device is not None:
             self._to_device.release()
 
+    def _reset(self, step, epoch):
+        if self._to_device is not None:
+            logger.info("Reset the dataset pipeline to step: " + str(step) + ", epoch: " + str(epoch))
+            self._to_device._reset(step, epoch)  # pylint: disable=protected-access
+
 
 class Schema:
     """
     Class to represent a schema of a dataset.
 
     Args:
-        schema_file(str): Path of the schema file (default=None).
+        schema_file(str): Path of the schema file. Default: None.
 
     Returns:
         Schema object, schema info about dataset.
@@ -3877,11 +4026,17 @@ class Schema:
         Args:
             name (str): The new name of the column.
             de_type (str): Data type of the column.
-            shape (list[int], optional): Shape of the column
-                (default=None, [-1] which is an unknown shape of rank 1).
+            shape (list[int], optional): Shape of the column.
+                Default: None, [-1] which is an unknown shape of rank 1.
 
         Raises:
             ValueError: If column type is unknown.
+
+        Examples:
+        >>> from mindspore import dtype as mstype
+        >>>
+        >>> schema = ds.Schema()
+        >>> schema.add_column('col_1d', de_type=mstype.int64, shape=[2])
         """
         if isinstance(de_type, typing.Type):
             de_type = mstype_to_detype(de_type)
@@ -3926,6 +4081,12 @@ class Schema:
 
         Returns:
             str, JSON string of the schema.
+
+        Examples:
+            >>> from mindspore.dataset import Schema
+            >>>
+            >>> schema1 = ds.Schema()
+            >>> schema2 = schema1.to_json()
         """
         return self.cpp_schema.to_json()
 
@@ -3940,6 +4101,16 @@ class Schema:
             RuntimeError: if there is unknown item in the object.
             RuntimeError: if dataset type is missing in the object.
             RuntimeError: if columns are missing in the object.
+
+        Examples:
+            >>> import json
+            >>>
+            >>> from mindspore.dataset import Schema
+            >>>
+            >>> with open("/path/to/schema_file") as file:
+            ...     json_obj = json.load(file)
+            ...     schema = ds.Schema()
+            ...     schema.from_json(json_obj)
         """
         self.cpp_schema.from_string(json.dumps(json_obj, indent=2))