mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-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
@@ -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, \
@@ -69,7 +71,7 @@ from .validators import check_batch, check_shuffle, check_map, check_filter, che
     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, 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,17 +116,19 @@ def _get_training_dataset():
     return _train_dataset
 
 
-def _reset_training_dataset(step, epoch):
+def _reset_training_dataset(global_step, dataset_size):
     """
-    Reset the training dataset to the given step and epoch number.
+    Reset the training dataset to the given global step.
 
     Args:
-        step (int): Global step number.
-        epoch (int): Global epoch 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, epoch)  # 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.")
 
@@ -450,6 +454,9 @@ class Dataset:
 
         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))
@@ -490,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
+                `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
+                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.
 
         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
@@ -571,9 +578,11 @@ class Dataset:
                   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. This option could be beneficial if the function is computational heavy.
-                  Default: False.
+                - 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.
@@ -586,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
@@ -599,7 +608,7 @@ 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
@@ -650,7 +659,7 @@ class Dataset:
             >>> # 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
+            >>> # 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
@@ -811,11 +820,11 @@ class Dataset:
         `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.0-alpha/api_python/mindspore.\
+          `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.0-alpha/api_python/mindspore.\
+          `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.0-alpha/api_python/mindspore.\
+          `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:
 
@@ -1316,6 +1325,16 @@ class Dataset:
 
         Returns:
             Dataset, dataset for transferring.
+
+        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()
         """
         return TransferDataset(self, send_epoch_end, create_data_info_queue)
 
@@ -1389,6 +1408,17 @@ class Dataset:
             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()
 
@@ -1417,7 +1447,7 @@ class Dataset:
                 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,
+            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:
@@ -1440,7 +1470,7 @@ 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.
 
@@ -1449,6 +1479,8 @@ class Dataset:
                 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.
 
         Returns:
             Iterator, dictionary iterator over the dataset.
@@ -1467,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."""
@@ -1689,6 +1721,39 @@ class Dataset:
                 When num_batch is None, it will default to the number specified by the
                 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):
@@ -1712,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
@@ -1761,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."""
@@ -1782,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):
         """
@@ -1837,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
@@ -1851,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, [])
@@ -1899,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.
@@ -1917,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}." \
@@ -2363,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.")
@@ -2658,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):
@@ -2764,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()):
@@ -2949,6 +3094,12 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
                     # For kill -15, we still exit after 30s
                     if exit_code == -15:
                         return 30
+                # In some cases the subprocess has been killed but the exitcode is still None.
+                # So we use os.kill(pid, 0) to check if it is alive.
+                subprocess_alive = _PythonMultiprocessing.is_process_alive(w.pid)
+                if not subprocess_alive:
+                    # Like kill -15, we wait 30s before exit
+                    return 30
             except ValueError:
                 # process has been closed already
                 return 0
@@ -2993,12 +3144,22 @@ 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.reset()
         self.create_pool()
@@ -3036,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()
 
@@ -3113,6 +3273,7 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
         if platform.system().lower() != 'windows':
             self.cleaning_process = multiprocessing.Process(target=self._clean_process,
                                                             args=(self.ppid, self.workers),
+                                                            name="OrphanCleaner",
                                                             daemon=True)
             self.cleaning_process.start()
 
@@ -3120,6 +3281,7 @@ class _PythonMultiprocessing(cde.PythonMultiprocessingRuntime):
                 self.eot = threading.Event()
                 self.watch_dog = threading.Thread(target=self._watch_dog,
                                                   args=(self.eot, self.workers + [self.cleaning_process]),
+                                                  name="WatchDog",
                                                   daemon=True)
                 self.watch_dog.start()
 
@@ -3212,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.")
@@ -3239,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):
         """
@@ -3304,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 = []
@@ -3334,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
@@ -3606,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()
@@ -3620,9 +3854,6 @@ class _ToDevice:
     def send(self):
         self._to_device.Send()
 
-    def _reset(self, step, epoch):
-        self._to_device.Reset(step, epoch)
-
     def stop_send(self):
         """
         send stop send signal to pipeline, it is used when end of sequence is sent at the epoch end.
@@ -3661,6 +3892,9 @@ 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):
     """
@@ -3731,11 +3965,6 @@ class TransferDataset(Dataset):
         if self._to_device is not None:
             self._to_device.continue_send()
 
-    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=W0212
-
     def get_data_info(self):
         """
         Get type and shape of current batch
@@ -3757,6 +3986,11 @@ 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:
     """
@@ -3797,6 +4031,12 @@ class Schema:
 
         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)
@@ -3841,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()
 
@@ -3855,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))