mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/dataset/transforms/__init__.py

@@ -31,7 +31,7 @@ Note: Legacy c_transforms and py_transforms are deprecated but can still be impo
     from mindspore.dataset.transforms import py_transforms
 
 See `Common Transforms
-<https://www.mindspore.cn/tutorials/en/r2.0/beginner/transforms.html#common-transforms>`_ tutorial for more details.
+<https://www.mindspore.cn/tutorials/en/r2.2/beginner/transforms.html#common-transforms>`_ tutorial for more details.
 
 Descriptions of common data processing terms are as follows:
 

mindspore/dataset/transforms/c_transforms.py

@@ -377,8 +377,9 @@ class Concatenate(TensorOperation):
     Args:
         axis (int, optional): Concatenate the tensors along given axis. Default: 0.
         prepend (numpy.array, optional): NumPy array to be prepended to the already concatenated tensors.
-            Default: None.
-        append (numpy.array, optional): NumPy array to be appended to the already concatenated tensors. Default: None.
+            Default: ``None``.
+        append (numpy.array, optional): NumPy array to be appended to the already concatenated tensors.
+            Default: ``None``.
 
     Raises:
         TypeError: If `axis` is not of type int.

mindspore/dataset/transforms/py_transforms_util.py

@@ -18,11 +18,12 @@ Built-in py_transforms_utils functions.
 import json
 import random
 from enum import IntEnum
-from types import FunctionType
+from types import FunctionType, MethodType
 import numpy as np
 
 from mindspore import log as logger
 from ..core.py_util_helpers import is_numpy, ExceptionHandler
+from .. import transforms as t
 
 
 class Implementation(IntEnum):
@@ -212,16 +213,43 @@ class FuncWrapper:
 
     def to_json(self):
         """ Serialize to JSON format """
-        if isinstance(self.transform, FunctionType):
-            # User-defined Python functions cannot be fully nor correctly serialized.
-            # Log a warning, and produce minimal info for the Python UDF, so that serialization of the
-            # dataset pipeline can continue.
-            # Note that the serialized JSON output is not valid to be deserialized.
-            logger.warning("Serialization of user-defined Python functions is not supported. "
-                           "Any produced serialized JSON file output for this dataset pipeline is not valid "
-                           "to be deserialized.")
+        # User-defined Python functions cannot be fully nor correctly serialized.
+        # Log a warning, and produce minimal info for the Python UDF, so that serialization of the
+        # dataset pipeline can continue.
+        # Note that the serialized JSON output is not valid to be deserialized.
+        udf_python_warning = "Serialization of user-defined Python functions is not supported. " \
+                             "Any produced serialized JSON file output for this dataset pipeline is not valid " \
+                             "to be deserialized."
+        try:
+            if isinstance(self.transform, (FunctionType, MethodType)):
+                # common function type(include lambda, class method) / object method
+                logger.warning(udf_python_warning)
+                json_obj = {}
+                json_obj["tensor_op_name"] = self.transform.__name__
+                json_obj["python_module"] = self.__class__.__module__
+                return json.dumps(json_obj)
+            if callable(self.transform) and not isinstance(self.transform, (t.c_transforms.TensorOperation,
+                                                                            t.py_transforms.PyTensorOperation,
+                                                                            t.transforms.TensorOperation,
+                                                                            t.transforms.PyTensorOperation,
+                                                                            FuncWrapper)):
+                # udf callable class
+                logger.warning(udf_python_warning)
+                json_obj = {}
+                json_obj["tensor_op_name"] = type(self.transform).__name__
+                json_obj["python_module"] = self.__class__.__module__
+                return json.dumps(json_obj)
+            # dataset operations
+            return self.transform.to_json()
+        except Exception as e:
+            logger.warning("Skip user-defined Python method which cannot be serialized, reason is: " + str(e))
             json_obj = {}
-            json_obj["tensor_op_name"] = self.transform.__name__
-            json_obj["python_module"] = self.__class__.__module__
+            json_obj["tensor_op_name"] = "unknown"
+            json_obj["python_module"] = "unknown"
             return json.dumps(json_obj)
-        return self.transform.to_json()
+
+    def release_resource(self):
+        # release the executor which is used by current thread/process when
+        # use transform in eager mode in map op or batch op
+        # this will be call in MapOp::WorkerEntry and BatchOp::WorkerEntry
+        t.transforms.clean_unused_executors()

mindspore/dataset/transforms/transforms.py

@@ -17,6 +17,8 @@ The module transforms provides common operations, including Compose, OneHot and
 """
 import json
 from abc import ABC
+import os
+import threading
 
 import sys
 from enum import IntEnum
@@ -36,6 +38,28 @@ from ..core.datatypes import mstype_to_detype, nptype_to_detype
 from ..vision.py_transforms_util import is_pil
 
 
+# hold all the executor objects when in training procedure
+# key : pid_tid which distinguishes multiple executors by process_id + thread_id
+# value : executor object which lifecycle will always exist during training
+EXECUTORS_LIST = dict()
+
+
+# the follow case process / thread exit need call the function
+# 1. user defined dataset with process mode
+# 2. user defined dataset with thread mode
+# 3. user defined transform in map op with process mode
+# 4. user defined transform in map op with thread mode
+# 5. batch op with per_batch_map operation in process mode
+# 6. batch op with per_batch_map operation in thread mode
+def clean_unused_executors():
+    """
+    clean the unused executor object in UDF or map with PyFunc process / thread mode
+    """
+    key = str(os.getpid()) + "_" + str(threading.currentThread().ident)
+    if key in EXECUTORS_LIST:
+        EXECUTORS_LIST.pop(key)
+
+
 class TensorOperation:
     """
     Base class Tensor Ops
@@ -44,7 +68,7 @@ class TensorOperation:
     def __init__(self):
         super().__init__()
         self.implementation = None
-        self.callable_op_ = None
+        self.device_target = "CPU"
 
     def __call__(self, *input_tensor_list):
         """
@@ -62,9 +86,22 @@ class TensorOperation:
             except (RuntimeError, TypeError):
                 raise TypeError("Invalid user input. Got {}: {}, cannot be converted into tensor." \
                                 .format(type(tensor), tensor))
-        if not hasattr(self, 'callable_op_') or self.callable_op_ is None:
-            self.callable_op_ = cde.Execute(self.parse())
-        output_tensor_list = self.callable_op_(tensor_row)
+
+        # get or create the executor from EXECUTORS_LIST
+        executor = None
+        key = str(os.getpid()) + "_" + str(threading.currentThread().ident)
+        if key in EXECUTORS_LIST:
+            # get the executor by process id and thread id
+            executor = EXECUTORS_LIST[key]
+            # remove the old transform which in executor and update the new transform
+            executor.UpdateOperation(self.parse())
+        else:
+            # create a new executor by process id and thread_id
+            executor = cde.Execute(self.parse())
+            # add the executor the global EXECUTORS_LIST
+            EXECUTORS_LIST[key] = executor
+
+        output_tensor_list = executor(tensor_row)
         output_numpy_list = [x.as_array() for x in output_tensor_list]
         return output_numpy_list[0] if len(output_numpy_list) == 1 else tuple(output_numpy_list)
 
@@ -220,12 +257,14 @@ class Compose(CompoundOperation):
         ``CPU``
 
     Examples:
-        >>> compose = transforms.Compose([vision.Decode(), vision.RandomCrop(512)])
-        >>> image_folder_dataset = image_folder_dataset.map(operations=compose)
-        >>> image_folder_dataset_dir = "/path/to/image_folder_dataset_directory"
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
+        >>> import mindspore.dataset.vision as vision
         >>>
         >>> # create a dataset that reads all files in dataset_dir with 8 threads
+        >>> image_folder_dataset_dir = "/path/to/image_folder_dataset_directory"
         >>> image_folder_dataset = ds.ImageFolderDataset(image_folder_dataset_dir, num_parallel_workers=8)
+        >>>
         >>> # create a list of transformations to be applied to the image data
         >>> transform = transforms.Compose([vision.Decode(to_pil=True),
         ...                                vision.RandomHorizontalFlip(0.5),
@@ -244,7 +283,7 @@ class Compose(CompoundOperation):
         ...                    vision.RandomErasing()]
         >>>
         >>> # apply the transform to the dataset through dataset.map()
-        >>> image_folder_dataset_1 = image_folder_dataset_1.map(operations=transforms_list, input_columns=["image"])
+        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list, input_columns=["image"])
         >>>
         >>> # Certain C++ and Python ops can be combined, but not all of them
         >>> # An example of combined operations
@@ -271,17 +310,16 @@ class Compose(CompoundOperation):
         if all(hasattr(transform, "random") and not transform.random for transform in self.transforms):
             self.random = False
 
+    # pylint: disable=missing-docstring
     @staticmethod
     def decompose(operations):
-        """
-        Remove all compose operation from the given list of operations.
-
-        Args:
-            operations (list): list of transforms.
-
-        Returns:
-            list of operations without compose operations.
-        """
+        # Remove all compose operation from the given list of operations.
+        #
+        # Args:
+        #    operations (list): list of transforms.
+        #
+        # Returns:
+        #    list of operations without compose operations.
         new_operations = []
         for op in operations:
             if isinstance(op, Compose):
@@ -290,17 +328,16 @@ class Compose(CompoundOperation):
                 new_operations.append(op)
         return new_operations
 
+    # pylint: disable=missing-docstring
     @staticmethod
     def reduce(operations):
-        """
-        Wraps adjacent Python operations in a Compose to allow mixing of Python and C++ operations.
-
-        Args:
-            operations (list): list of tensor operations.
-
-        Returns:
-            list, the reduced list of operations.
-        """
+        # Wraps adjacent Python operations in a Compose to allow mixing of Python and C++ operations.
+        #
+        # Args:
+        #    operations (list): list of tensor operations.
+        #
+        # Returns:
+        #    list, the reduced list of operations.
         new_ops, start_ind, end_ind = [], 0, 0
         for i, op in enumerate(operations):
             if op.implementation == Implementation.C and not isinstance(op, FuncWrapper):
@@ -340,16 +377,31 @@ class Compose(CompoundOperation):
         """
         return util.compose(self.transforms, *args)
 
+    def __call__(self, *args):
+        '''
+        If PY op exists in self.transforms, should use _execute_py to keep the output types unchanged.
+        '''
+        if any([t.implementation == Implementation.PY for t in self.transforms]):
+            self.implementation = Implementation.PY
+        return super().__call__(*args)
+
+    def release_resource(self):
+        # release the executor which is used by current thread/process when
+        # use transform in eager mode in map op
+        # this will be call in MapOp::WorkerEntry
+        clean_unused_executors()
+
 
 class Concatenate(TensorOperation):
     """
     Tensor operation that concatenates all columns into a single tensor, only 1D tenspr is supported.
 
     Args:
-        axis (int, optional): Concatenate the tensors along given axis. Default: 0.
+        axis (int, optional): Concatenate the tensors along given axis. Default: ``0``.
         prepend (numpy.ndarray, optional): NumPy array to be prepended to the already concatenated tensors.
-            Default: None.
-        append (numpy.ndarray, optional): NumPy array to be appended to the already concatenated tensors. Default: None.
+            Default: ``None``.
+        append (numpy.ndarray, optional): NumPy array to be appended to the already concatenated tensors.
+            Default: ``None``.
 
     Raises:
         TypeError: If `axis` is not of type int.
@@ -360,7 +412,10 @@ class Concatenate(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> import numpy as np
+        >>>
         >>> # concatenate string
         >>> prepend_tensor = np.array(["dw", "df"], dtype='S')
         >>> append_tensor = np.array(["dwsdf", "df"], dtype='S')
@@ -393,6 +448,8 @@ class Duplicate(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> # Data before
         >>> # |  x      |
         >>> # +---------+
@@ -435,7 +492,10 @@ class Fill(TensorOperation):
 
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> import numpy as np
+        >>>
         >>> # generate a 1D integer numpy array from 0 to 4
         >>> def generator_1d():
         ...     for i in range(5):
@@ -463,10 +523,11 @@ class Mask(TensorOperation):
     Any element of the tensor that matches the predicate will be evaluated to True, otherwise False.
 
     Args:
-        operator (Relational): relational operators, it can be any of [Relational.EQ, Relational.NE, Relational.LT,
-            Relational.GT, Relational.LE, Relational.GE], take Relational.EQ as example, EQ refers to equal.
+        operator (Relational): relational operators, it can be ``Relational.EQ``, ``Relational.NE``, ``Relational.LT``,
+            ``Relational.GT``, ``Relational.LE``, ``Relational.GE``, take ``Relational.EQ`` as example,
+            EQ refers to equal.
         constant (Union[str, int, float, bool]): Constant to be compared to.
-        dtype (mindspore.dtype, optional): Type of the generated mask. Default: mindspore.dtype.bool\_.
+        dtype (mindspore.dtype, optional): Type of the generated mask. Default: ``mstype.bool_``.
 
     Raises:
         TypeError: `operator` is not of type Relational.
@@ -477,6 +538,8 @@ class Mask(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> from mindspore.dataset.transforms import Relational
         >>> # Data before
         >>> # |  col   |
@@ -507,25 +570,36 @@ class Mask(TensorOperation):
 
 class OneHot(TensorOperation):
     """
-    Tensor operation to apply one hot encoding.
+    Apply One-Hot encoding to the input labels.
+
+    For a 1-D input of shape :math:`(*)`, an output of shape :math:`(*, num_classes)` will be
+    returned, where the elements with index values equal to the input values will be set to 1,
+    and the rest will be set to 0. If a label smoothing rate is specified, the element values
+    are further smoothed to enhance generalization.
 
     Args:
-        num_classes (int): Number of classes of objects in dataset.
-            It should be larger than the largest label number in the dataset.
-        smoothing_rate (float, optional): Adjustable hyperparameter for label smoothing level.
-            Default: 0.0, means no smoothing is applied.
+        num_classes (int): Total number of classes. Must be greater than the maximum value
+            of the input labels.
+        smoothing_rate (float, optional): The amount of label smoothing. Must be between
+            [0.0, 1.0]. Default: ``0.0``, no label smoothing.
 
     Raises:
-        TypeError: `num_classes` is not of type int.
-        TypeError: `smoothing_rate` is not of type float or int.
-        ValueError: `smoothing_rate` is not in range [0.0, 1.0].
-        RuntimeError: Input tensor is not of type int.
-        RuntimeError: Input tensor is not a 1-D tensor.
+        TypeError: If `num_classes` is not of type int.
+        TypeError: If `smoothing_rate` is not of type float.
+        ValueError: If `smoothing_rate` is not in range of [0.0, 1.0].
+        RuntimeError: If input label is not of type int.
+        RuntimeError: If the dimension of the input label is not 1.
 
     Supported Platforms:
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
+        >>>
+        >>> mnist_dataset_dir = "/path/to/mnist_dataset_directory"
+        >>> mnist_dataset = ds.MnistDataset(dataset_dir=mnist_dataset_dir)
+        >>>
         >>> # Assume that dataset has 10 classes, thus the label ranges from 0 to 9
         >>> onehot_op = transforms.OneHot(num_classes=10)
         >>> mnist_dataset = mnist_dataset.map(operations=onehot_op, input_columns=["label"])
@@ -547,10 +621,10 @@ class PadEnd(TensorOperation):
     Pad input tensor according to pad_shape, input tensor needs to have same rank.
 
     Args:
-        pad_shape (list(int)): List of integers representing the shape needed. Dimensions that set to `None` will
+        pad_shape (list(int)): List of integers representing the shape needed. Dimensions that set to ``None`` will
             not be padded (i.e., original dim will be used). Shorter dimensions will truncate the values.
-        pad_value (Union[str, bytes, int, float, bool], optional): Value used to pad. Default to 0 or empty
-            string in case of tensors of strings.
+        pad_value (Union[str, bytes, int, float, bool], optional): Value used to pad. Default: ``None``.
+            Default to ``0`` in case of tensors of Numbers, or empty string in case of tensors of strings.
 
     Raises:
         TypeError: If `pad_shape` is not of type list.
@@ -562,6 +636,8 @@ class PadEnd(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> # Data before
         >>> # |   col   |
         >>> # +---------+
@@ -607,7 +683,11 @@ class Plugin(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
+        >>>
         >>> plugin = transforms.Plugin("pluginlib.so", "PluginDecode")
+        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
         >>> image_folder_dataset = image_folder_dataset.map(operations=plugin)
     """
 
@@ -629,7 +709,7 @@ class RandomApply(CompoundOperation):
 
     Args:
         transforms (list): List of transformations to be applied.
-        prob (float, optional): The probability to apply the transformation list. Default: 0.5.
+        prob (float, optional): The probability to apply the transformation list. Default: ``0.5``.
 
     Raises:
         TypeError: If `transforms` is not of type list.
@@ -643,13 +723,19 @@ class RandomApply(CompoundOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
+        >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
+        >>>
         >>> transforms_list = [vision.RandomHorizontalFlip(0.5),
         ...                    vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
         ...                    vision.RandomErasing()]
         >>> composed_transform = Compose([vision.Decode(to_pil=True),
         ...                               transforms.RandomApply(transforms_list, prob=0.6),
         ...                               vision.ToTensor()])
+        >>>
+        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
         >>> image_folder_dataset = image_folder_dataset.map(operations=composed_transform, input_columns=["image"])
     """
 
@@ -692,13 +778,19 @@ class RandomChoice(CompoundOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
+        >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
+        >>>
         >>> transforms_list = [vision.RandomHorizontalFlip(0.5),
         ...                    vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
         ...                    vision.RandomErasing()]
         >>> composed_transform = Compose([vision.Decode(),
         ...                               transforms.RandomChoice(transforms_list),
         ...                               vision.ToTensor()])
+        >>>
+        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
         >>> image_folder_dataset = image_folder_dataset.map(operations=composed_transform, input_columns=["image"])
 
     """
@@ -742,13 +834,19 @@ class RandomOrder(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.vision as vision
+        >>> import mindspore.dataset.transforms as transforms
         >>> from mindspore.dataset.transforms import Compose
+        >>>
         >>> transforms_list = [vision.RandomHorizontalFlip(0.5),
         ...                    vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262)),
         ...                    vision.RandomErasing()]
         >>> composed_transform = Compose([vision.Decode(to_pil=False),
         ...                               transforms.RandomOrder(transforms_list),
         ...                               vision.ToTensor()])
+        >>>
+        >>> image_folder_dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory")
         >>> image_folder_dataset = image_folder_dataset.map(operations=composed_transform, input_columns=["image"])
     """
 
@@ -773,17 +871,16 @@ class RandomOrder(PyTensorOperation):
 
 class Relational(IntEnum):
     """
-    Relationship operator.
+    Relational operator.
 
-    Possible enumeration values are: Relational.EQ, Relational.NE, Relational.GT, Relational.GE, Relational.LT,
-    Relational.LE.
+    Available values are as follows:
 
-    - Relational.EQ: refers to Equality.
-    - Relational.NE: refers not equal, or Inequality.
-    - Relational.GT: refers to Greater than.
-    - Relational.GE: refers to Greater than or equal to.
-    - Relational.LT: refers to Less than.
-    - Relational.LE: refers to Less than or equal to.
+    - Relational.EQ: Equal to.
+    - Relational.NE: Not equal to.
+    - Relational.GT: Greater than.
+    - Relational.GE: Greater than or equal to.
+    - Relational.LT: Less than.
+    - Relational.LE: Less than or equal to.
     """
     EQ = 0
     NE = 1
@@ -829,30 +926,31 @@ class _SliceOption(cde.SliceOption):
 
 class Slice(TensorOperation):
     """
-    Slice operation to extract a tensor out using the given n slices.
+    Extract a slice from the input.
 
-    The functionality of Slice is similar to NumPy's indexing feature (Currently only rank-1 tensors are supported).
+    Currently, only 1-D input is supported.
 
     Args:
-        slices (Union[int, list[int], slice, None, Ellipsis]):
-            Maximum `n` number of arguments to slice a tensor of rank `n` .
-            One object in slices can be one of:
-
-            1.  :py:obj:`int`: Slice this index only along the first dimension. Negative index is supported.
-            2.  :py:obj:`list(int)`: Slice these indices along the first dimension. Negative indices are supported.
-            3.  :py:obj:`slice`: Slice the generated indices from the
-                `slice <https://docs.python.org/3.7/library/functions.html?highlight=slice#slice>`_ object along the
-                first dimension. Similar to start:stop:step.
-            4.  :py:obj:`None`: Slice the whole dimension. Similar to :py:obj:`[:]` in Python indexing.
-            5.  :py:obj:`Ellipsis`: Slice the whole dimension, same result with `None` .
+        slices (Union[int, list[int], slice, Ellipsis]): The desired slice.
+            If the input type is int, it will slice the element with the specified index value.
+            Negative index is also supported.
+            If the input type is list[int], it will slice all the elements with the specified index values.
+            Negative index is also supported.
+            If the input type is `slice <https://docs.python.org/3.7/library/functions.html#slice>`_ ,
+            it will slice according to its specified start position, stop position and step size.
+            If the input type is `Ellipsis <https://docs.python.org/3.7/library/constants.html#Ellipsis>`_ ,
+            all elements will be sliced.
+            If the input is None, all elements will be sliced.
 
     Raises:
-        TypeError: If `slices` is not of type int, list[int], :py:obj:`slice` , :py:obj:`None` or :py:obj:`Ellipsis` .
+        TypeError: If `slices` is not of type Union[int, list[int], slice, Ellipsis].
 
     Supported Platforms:
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> # Data before
         >>> # |   col   |
         >>> # +---------+
@@ -886,7 +984,8 @@ class TypeCast(TensorOperation):
     Tensor operation to cast to a given MindSpore data type or NumPy data type.
 
     Note:
-        This operation supports running on Ascend or GPU platforms by Offload.
+        This operation is executed on the CPU by default, but it is also supported
+        to be executed on the GPU or Ascend via heterogeneous acceleration.
 
     Args:
         data_type (Union[mindspore.dtype, numpy.dtype]): mindspore.dtype or numpy.dtype (e.g. `numpy.float32`)
@@ -896,9 +995,11 @@ class TypeCast(TensorOperation):
         TypeError: If `data_type` is not of MindSpore data type bool, int, float, string or type :class:`numpy.dtype` .
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``CPU`` ``GPU`` ``Ascend``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> import numpy as np
         >>> from mindspore import dtype as mstype
         >>>
@@ -947,6 +1048,8 @@ class Unique(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import mindspore.dataset as ds
+        >>> import mindspore.dataset.transforms as transforms
         >>> # Data before
         >>> # |  x                 |
         >>> # +--------------------+

mindspore/dataset/utils/browse_dataset.py

@@ -28,33 +28,41 @@ def imshow_det_bbox(image, bboxes, labels, segm=None, class_names=None, score_th
     """Draw an image with given bboxes and class labels (with scores).
 
     Args:
-        image (numpy.ndarray): The image to be displayed, shaped (C, H, W) or (H, W, C), formatted RGB.
-        bboxes (numpy.ndarray): Bounding boxes (with scores), shaped (N, 4) or (N, 5),
+        image (numpy.ndarray): The image to be displayed, shaped :math:`(C, H, W)` or :math:`(H, W, C)`,
+            formatted RGB.
+        bboxes (numpy.ndarray): Bounding boxes (with scores), shaped :math:`(N, 4)` or :math:`(N, 5)`,
             data should be ordered with (N, x, y, w, h).
-        labels (numpy.ndarray): Labels of bboxes, shaped (N, 1).
-        segm (numpy.ndarray): The segmentation masks of image in M classes, shaped (M, H, W). Default: None.
+        labels (numpy.ndarray): Labels of bboxes, shaped :math:`(N, 1)`.
+        segm (numpy.ndarray): The segmentation masks of image in M classes, shaped :math:`(M, H, W)`.
+            Default: ``None``.
         class_names (list[str], tuple[str], dict): Names of each class to map label to class name.
-            Default: None, only display label.
-        score_threshold (float): Minimum score of bboxes to be shown. Default: 0.
+            Default: ``None``, only display label.
+        score_threshold (float): Minimum score of bboxes to be shown. Default: ``0``.
         bbox_color (tuple(int)): Color of bbox lines.
-            The tuple of color should be in BGR order. Default: (0, 255 ,0), means 'green'.
+            The tuple of color should be in BGR order. Default: ``(0, 255 ,0)``, means 'green'.
         text_color (tuple(int)): Color of texts.
-            The tuple of color should be in BGR order. Default: (203, 192, 255), means 'pink'.
+            The tuple of color should be in BGR order. Default: ``(203, 192, 255)``, means 'pink'.
         mask_color (tuple(int)): Color of mask.
-            The tuple of color should be in BGR order. Default: (128, 0, 128), means 'purple'.
-        thickness (int): Thickness of lines. Default: 2.
-        font_size (int, float): Font size of texts. Default: 0.8.
-        show (bool): Whether to show the image. Default: True.
-        win_name (str): The window name. Default: "win".
-        wait_time (int): Value of waitKey param. Default: 2000, means display interval is 2000ms.
-        out_file (str, optional): The filename to write the imagee. Default: None. File extension name
+            The tuple of color should be in BGR order. Default: ``(128, 0, 128)``, means 'purple'.
+        thickness (int): Thickness of lines. Default: ``2``.
+        font_size (int, float): Font size of texts. Default: ``0.8``.
+        show (bool): Whether to show the image. Default: ``True``.
+        win_name (str): The window name. Default: ``"win"``.
+        wait_time (int): Waiting time delay for a key event in milliseconds. During image display,
+            if there is no key pressed, wait for this time then jump to next image. If ESC is pressed,
+            quit display immediately. If any other key is pressed, stop waiting then jump to
+            next image directly. Default: ``2000`` , wait 2000ms then jump to next image.
+        out_file (str, optional): The filename to write the imagee. Default: ``None``. File extension name
             is required to indicate the image compression type, e.g. 'jpg', 'png'.
 
     Returns:
         ndarray, The image with bboxes drawn on it.
 
+    Note:
+        This interface relies on the `opencv-python` library.
+
     Raises:
-        ImportError: If opencv-python is not installed.
+        ImportError: If `opencv-python` is not installed.
         AssertionError: If `image` is not in (H, W, C) or (C, H, W) format.
         AssertionError: If `bboxes` is not in (N, 4) or (N, 5) format.
         AssertionError: If `labels` is not in (N, 1) format.
@@ -67,7 +75,7 @@ def imshow_det_bbox(image, bboxes, labels, segm=None, class_names=None, score_th
     Examples:
         >>> import numpy as np
         >>> import mindspore.dataset as ds
-        >>> from mindspore.dataset.utils.browse_dataset import imshow_det_bbox
+        >>> from mindspore.dataset.utils import imshow_det_bbox
         >>>
         >>> # Read Detection dataset, such as VOC2012.
         >>> voc_dataset_dir = "/path/to/voc_dataset_directory"