mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/dataset/transforms/transforms.py

@@ -74,6 +74,11 @@ class TensorOperation:
         """
         Call method.
         """
+        # Check PIL Image with device_target
+        if (len(input_tensor_list) == 1 and is_pil(input_tensor_list[0])) and self.device_target == "Ascend":
+            raise TypeError("The input PIL Image cannot be executed on Ascend, "
+                            "you can convert the input to the numpy ndarray type.")
+
         # Check if Python implementation of op, or PIL input
         if (self.implementation == Implementation.PY) or \
                 (len(input_tensor_list) == 1 and is_pil(input_tensor_list[0]) and getattr(self, '_execute_py', None)):
@@ -257,50 +262,74 @@ class Compose(CompoundOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
         >>> import mindspore.dataset.vision as vision
+        >>> from mindspore.dataset.transforms import Relational
         >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # 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)
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
         >>>
         >>> # create a list of transformations to be applied to the image data
-        >>> transform = transforms.Compose([vision.Decode(to_pil=True),
-        ...                                vision.RandomHorizontalFlip(0.5),
-        ...                                vision.ToTensor(),
-        ...                                vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262), is_hwc=False),
-        ...                                vision.RandomErasing()])
+        >>> transform = transforms.Compose([
+        ...     vision.RandomHorizontalFlip(0.5),
+        ...     vision.ToTensor(),
+        ...     vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262), is_hwc=False),
+        ...     vision.RandomErasing()])
         >>> # apply the transform to the dataset through dataset.map function
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transform, input_columns=["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transform, input_columns=["image"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 100, 100) float32
         >>>
         >>> # Compose is also be invoked implicitly, by just passing in a list of ops
         >>> # the above example then becomes:
-        >>> transforms_list = [vision.Decode(to_pil=True),
-        ...                    vision.RandomHorizontalFlip(0.5),
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> transforms_list = [vision.RandomHorizontalFlip(0.5),
         ...                    vision.ToTensor(),
         ...                    vision.Normalize((0.491, 0.482, 0.447), (0.247, 0.243, 0.262), is_hwc=False),
         ...                    vision.RandomErasing()]
         >>>
         >>> # apply the transform to the dataset through dataset.map()
-        >>> image_folder_dataset = image_folder_dataset.map(operations=transforms_list, input_columns=["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms_list, input_columns=["image"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 100, 100) float32
         >>>
         >>> # Certain C++ and Python ops can be combined, but not all of them
         >>> # An example of combined operations
         >>> arr = [0, 1]
-        >>> dataset = ds.NumpySlicesDataset(arr, column_names=["cols"], shuffle=False)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(arr, column_names=["cols"], shuffle=False)
         >>> transformed_list = [transforms.OneHot(2),
         ...                     transforms.Mask(transforms.Relational.EQ, 1)]
-        >>> dataset = dataset.map(operations=transformed_list, input_columns=["cols"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transformed_list, input_columns=["cols"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["cols"].shape, item["cols"].dtype)
+        ...     break
+        (2,) bool
         >>>
         >>> # Here is an example of mixing vision ops
-        >>> import numpy as np
-        >>> op_list=[vision.Decode(),
-        ...          vision.Resize((224, 244)),
+        >>> op_list=[vision.Resize((224, 244)),
         ...          vision.ToPIL(),
         ...          np.array, # need to convert PIL image to a NumPy array to pass it to C++ operation
         ...          vision.Resize((24, 24))]
-        >>> image_folder_dataset = image_folder_dataset.map(operations=op_list,  input_columns=["image"])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=op_list,  input_columns=["image"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (24, 24, 3) uint8
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([1, 2, 3])
+        >>> output = transforms.Compose([transforms.Fill(10), transforms.Mask(Relational.EQ, 100)])(data)
+        >>> print(output.shape, output.dtype)
+        (3,) bool
     """
 
     @check_random_transform_ops
@@ -394,14 +423,14 @@ class Compose(CompoundOperation):
 
 class Concatenate(TensorOperation):
     """
-    Tensor operation that concatenates all columns into a single tensor, only 1D tenspr is supported.
+    Concatenate data with input array along given axis, only 1D data is supported.
 
     Args:
-        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``.
+        axis (int, optional): The axis along which the arrays will be concatenated. Default: ``0``.
+        prepend (numpy.ndarray, optional): NumPy array to be prepended to the input array.
+            Default: ``None``, not to prepend array.
+        append (numpy.ndarray, optional): NumPy array to be appended to the input array.
+            Default: ``None``, not to append array.
 
     Raises:
         TypeError: If `axis` is not of type int.
@@ -412,17 +441,29 @@ class Concatenate(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
-        >>> import numpy as np
         >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # concatenate string
-        >>> prepend_tensor = np.array(["dw", "df"], dtype='S')
-        >>> append_tensor = np.array(["dwsdf", "df"], dtype='S')
+        >>> prepend_tensor = np.array(["dw", "df"])
+        >>> append_tensor = np.array(["dwsdf", "df"])
         >>> concatenate_op = transforms.Concatenate(0, prepend_tensor, append_tensor)
         >>> data = [["This","is","a","string"]]
-        >>> dataset = ds.NumpySlicesDataset(data)
-        >>> dataset = dataset.map(operations=concatenate_op)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data)
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=concatenate_op)
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["column_0"].shape, item["column_0"].dtype)
+        (8,) <U6
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([1, 2, 3])
+        >>> prepend_tensor = np.array([10, 20])
+        >>> append_tensor = np.array([100])
+        >>> output = transforms.Concatenate(0, prepend_tensor, append_tensor)(data)
+        >>> print(output.shape, output.dtype)
+        (6,) int64
     """
 
     @check_concat_type
@@ -448,8 +489,11 @@ class Duplicate(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
+        >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # Data before
         >>> # |  x      |
         >>> # +---------+
@@ -460,11 +504,22 @@ class Duplicate(TensorOperation):
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.Duplicate(),
         ...                                                 input_columns=["x"],
         ...                                                 output_columns=["x", "y"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["x"].shape, item["x"].dtype)
+        ...     print(item["y"].shape, item["y"].dtype)
+        (3,) int64
+        (3,) int64
         >>> # Data after
         >>> # |  x      |  y      |
         >>> # +---------+---------+
         >>> # | [1,2,3] | [1,2,3] |
         >>> # +---------+---------+
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = [1, 2, 3]
+        >>> output = transforms.Duplicate()(data)
+        >>> print(np.array(output).shape, np.array(output).dtype)
+        (2, 3) int64
     """
 
     def __init__(self):
@@ -492,10 +547,11 @@ class Fill(TensorOperation):
 
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
-        >>> import numpy as np
         >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # generate a 1D integer numpy array from 0 to 4
         >>> def generator_1d():
         ...     for i in range(5):
@@ -504,7 +560,16 @@ class Fill(TensorOperation):
         >>> # [[0], [1], [2], [3], [4]]
         >>> fill_op = transforms.Fill(3)
         >>> generator_dataset = generator_dataset.map(operations=fill_op)
-        >>> # [[3], [3], [3], [3], [3]]
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["col1"].shape, item["col1"].dtype)
+        ...     break
+        (1,) int64
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([1, 2, 3])
+        >>> output = transforms.Fill(100)(data)
+        >>> print(output.shape, output.dtype)
+        (3,) int64
     """
 
     @check_fill_value
@@ -541,6 +606,8 @@ class Mask(TensorOperation):
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
         >>> from mindspore.dataset.transforms import Relational
+        >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # Data before
         >>> # |  col   |
         >>> # +---------+
@@ -549,11 +616,20 @@ class Mask(TensorOperation):
         >>> data = [[1, 2, 3]]
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["col"])
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.Mask(Relational.EQ, 2))
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["col"].shape, item["col"].dtype)
+        (3,) bool
         >>> # Data after
         >>> # |       col         |
         >>> # +--------------------+
         >>> # | [False,True,False] |
         >>> # +--------------------+
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = [1, 2, 3]
+        >>> output = transforms.Mask(Relational.EQ, 2)(data)
+        >>> print(output.shape, output.dtype)
+        (3,) bool
     """
 
     @check_mask_op_new
@@ -569,10 +645,10 @@ class Mask(TensorOperation):
 
 
 class OneHot(TensorOperation):
-    """
+    r"""
     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
+    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.
@@ -594,15 +670,27 @@ class OneHot(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> 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)
+        >>> # Use the transform in dataset pipeline mode
+        >>> data = [1, 2, 3, 4, 5, 6, 7, 8]
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["label"])
         >>>
         >>> # 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"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=onehot_op, input_columns=["label"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["label"].shape, item["label"].dtype)
+        ...     break
+        (10,) int64
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([1, 2, 3])
+        >>> output = transforms.OneHot(num_classes=5, smoothing_rate=0)(data)
+        >>> print(output.shape, output.dtype)
+        (3, 5) int64
     """
 
     @check_one_hot_op
@@ -638,6 +726,8 @@ class PadEnd(TensorOperation):
     Examples:
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
+        >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # Data before
         >>> # |   col   |
         >>> # +---------+
@@ -645,13 +735,22 @@ class PadEnd(TensorOperation):
         >>> # +---------|
         >>> data = [[1, 2, 3]]
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["col"])
-        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.PadEnd(pad_shape=[4],
-        ...                                                                                pad_value=10))
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.PadEnd(pad_shape=[4], pad_value=10))
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["col"].shape, item["col"].dtype)
+        ...     break
+        (4,) int64
         >>> # Data after
         >>> # |    col     |
         >>> # +------------+
         >>> # | [1,2,3,10] |
         >>> # +------------|
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = [1, 2, 3]
+        >>> output = transforms.PadEnd(pad_shape=[4], pad_value=10)(data)
+        >>> print(output.shape, output.dtype)
+        (4,) int64
     """
 
     @check_pad_end
@@ -723,20 +822,36 @@ class RandomApply(CompoundOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> seed = ds.config.get_seed()
+        >>> ds.config.set_seed(12345)
         >>> 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),
+        >>> composed_transform = Compose([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"])
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=composed_transform, input_columns=["image"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.random.randint(0, 255, size=(100, 100, 3)).astype(np.uint8)
+        >>> transform = [vision.HsvToRgb(is_hwc=True), vision.Crop((0, 0), 10), vision.ToTensor()]
+        >>> output = transforms.RandomApply(transform, prob=1.0)(data)
+        >>> print(output.shape, output.dtype)
+        (3, 10, 10) float32
+        >>> ds.config.set_seed(seed)
     """
 
     @check_random_transform_ops
@@ -763,10 +878,10 @@ class RandomApply(CompoundOperation):
 
 class RandomChoice(CompoundOperation):
     """
-    Randomly select one transform from a list of transforms to perform operation.
+    Randomly select one transform from a list to apply.
 
     Args:
-        transforms (list): List of transformations to be chosen from to apply.
+        transforms (list): List of transforms to be selected from.
 
     Raises:
         TypeError: If `transforms` is not of type list.
@@ -778,21 +893,35 @@ class RandomChoice(CompoundOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
         >>> import mindspore.dataset.vision as vision
         >>> from mindspore.dataset.transforms import Compose
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> seed = ds.config.get_seed()
+        >>> ds.config.set_seed(12345)
         >>> 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),
+        >>> composed_transform = Compose([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"])
-
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=composed_transform, input_columns=["image"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([1, 2, 3])
+        >>> output = transforms.RandomChoice([transforms.Fill(100)])(data)
+        >>> print(output.shape, output.dtype)
+        (3,) int64
+        >>> ds.config.set_seed(seed)
     """
 
     @check_random_transform_ops
@@ -834,20 +963,35 @@ class RandomOrder(PyTensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
-        >>> import mindspore.dataset.vision as vision
         >>> import mindspore.dataset.transforms as transforms
-        >>> from mindspore.dataset.transforms import Compose
+        >>> import mindspore.dataset.vision as vision
+        >>> from mindspore.dataset.transforms import Compose, Relational
         >>>
+        >>> # Use the transform in dataset pipeline mode
+        >>> seed = ds.config.get_seed()
+        >>> ds.config.set_seed(12345)
         >>> 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),
+        >>> composed_transform = Compose([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"])
+        >>> data = np.random.randint(0, 255, size=(1, 100, 100, 3)).astype(np.uint8)
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["image"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=composed_transform, input_columns=["image"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["image"].shape, item["image"].dtype)
+        ...     break
+        (3, 100, 100) float32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([1, 2, 3])
+        >>> output = transforms.RandomOrder([transforms.Mask(Relational.EQ, 100)])(data)
+        >>> print(output.shape, output.dtype)
+        (3,) bool
+        >>> ds.config.set_seed(seed)
     """
 
     @check_random_transform_ops
@@ -875,12 +1019,12 @@ class Relational(IntEnum):
 
     Available values are as follows:
 
-    - 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.
+    - ``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
@@ -932,15 +1076,16 @@ class Slice(TensorOperation):
 
     Args:
         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.
+
+            - 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 Union[int, list[int], slice, Ellipsis].
@@ -949,8 +1094,11 @@ class Slice(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
+        >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # Data before
         >>> # |   col   |
         >>> # +---------+
@@ -960,11 +1108,21 @@ class Slice(TensorOperation):
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["col"])
         >>> # slice indices 1 and 2 only
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.Slice(slice(1,3)))
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["col"].shape, item["col"].dtype)
+        ...     break
+        (2,) int64
         >>> # Data after
         >>> # |   col   |
         >>> # +---------+
         >>> # |  [2,3]  |
         >>> # +---------|
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([1, 2, 3])
+        >>> output = transforms.Slice(slice(1, 3))(data)
+        >>> print(output.shape, output.dtype)
+        (2,) int64
     """
 
     @check_slice_op
@@ -998,19 +1156,30 @@ class TypeCast(TensorOperation):
         ``CPU`` ``GPU`` ``Ascend``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
-        >>> import numpy as np
         >>> from mindspore import dtype as mstype
         >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # Generate 1d int numpy array from 0 - 63
         >>> def generator_1d():
         ...     for i in range(64):
         ...         yield (np.array([i]),)
         >>>
-        >>> dataset = ds.GeneratorDataset(generator_1d, column_names='col')
+        >>> generator_dataset = ds.GeneratorDataset(generator_1d, column_names='col')
         >>> type_cast_op = transforms.TypeCast(mstype.int32)
-        >>> dataset = dataset.map(operations=type_cast_op)
+        >>> generator_dataset = generator_dataset.map(operations=type_cast_op)
+        >>> for item in generator_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["col"].shape, item["col"].dtype)
+        ...     break
+        (1,) int32
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = np.array([2.71606445312564e-03, 6.3476562564e-03]).astype(np.float64)
+        >>> output = transforms.TypeCast(np.float16)(data)
+        >>> print(output.shape, output.dtype)
+        (2,) float16
     """
 
     @check_type_cast
@@ -1048,23 +1217,39 @@ class Unique(TensorOperation):
         ``CPU``
 
     Examples:
+        >>> import numpy as np
         >>> import mindspore.dataset as ds
         >>> import mindspore.dataset.transforms as transforms
+        >>>
+        >>> # Use the transform in dataset pipeline mode
         >>> # Data before
         >>> # |  x                 |
         >>> # +--------------------+
         >>> # | [[0,1,2], [1,2,3]] |
         >>> # +--------------------+
         >>> data = [[[0,1,2], [1,2,3]]]
-        >>> dataset = ds.NumpySlicesDataset(data, ["x"])
-        >>> dataset = dataset.map(operations=transforms.Unique(),
-        ...                       input_columns=["x"],
-        ...                       output_columns=["x", "y", "z"])
+        >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["x"])
+        >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.Unique(),
+        ...                                                 input_columns=["x"],
+        ...                                                 output_columns=["x", "y", "z"])
+        >>> for item in numpy_slices_dataset.create_dict_iterator(num_epochs=1, output_numpy=True):
+        ...     print(item["x"].shape, item["y"].shape, item["z"].shape)
+        ...     print(item["x"].dtype, item["y"].dtype, item["z"].dtype)
+        (4,) (6,) (4,)
+        int64 int32 int32
         >>> # Data after
         >>> # |  x      |  y              |z        |
         >>> # +---------+-----------------+---------+
         >>> # | [0,1,2,3] | [0,1,2,1,2,3] | [1,2,2,1]
         >>> # +---------+-----------------+---------+
+        >>>
+        >>> # Use the transform in eager mode
+        >>> data = [[0, -1, -2, -1, 2], [2, -0, 2, 1, -3]]
+        >>> output = transforms.Unique()(data)
+        >>> print(output[0].shape, output[1].shape, output[2].shape)
+        (6,) (10,) (6,)
+        >>> print(output[0].dtype, output[1].dtype, output[2].dtype)
+        int64 int32 int32
     """
 
     def __init__(self):

mindspore/dataset/utils/browse_dataset.py

@@ -28,12 +28,12 @@ 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 :math:`(C, H, W)` or :math:`(H, W, C)`,
+        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 :math:`(N, 1)`.
-        segm (numpy.ndarray): The segmentation masks of image in M classes, shaped :math:`(M, H, W)`.
+        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 :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.
@@ -63,10 +63,10 @@ def imshow_det_bbox(image, bboxes, labels, segm=None, class_names=None, score_th
 
     Raises:
         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.
-        AssertionError: If `segm` is not in (M, H, W) format.
+        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.
+        AssertionError: If `segm` is not in <M, H, W> format.
         AssertionError: If `class_names` is not of type list, tuple or dict.
         AssertionError: If `bbox_color` is not a tuple in format of (B, G, R).
         AssertionError: If `text_color` is not a tuple in format of (B, G, R).