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

mindspore/dataset/text/utils.py

@@ -36,16 +36,25 @@ class CharNGram(cde.CharNGram):
     @check_from_file_vectors
     def from_file(cls, file_path, max_vectors=None):
         """
-        Build a CharNGram vector from a file.
+        Build a `CharNGram` vector from a file.
 
         Args:
-            file_path (str): Path of the file that contains the CharNGram vectors.
+            file_path (str): Path of the file that contains the `CharNGram` vectors.
             max_vectors (int, optional): This can be used to limit the number of pre-trained vectors loaded.
                 Most pre-trained vector sets are sorted in the descending order of word frequency. Thus, in
-                situations where the entire set doesn’t fit in memory, or is not needed for another reason,
-                passing max_vectors can limit the size of the loaded set (default=None, no limit).
+                situations where the entire set doesn't fit in memory, or is not needed for another reason,
+                passing `max_vectors` can limit the size of the loaded set. Default: None, no limit.
+
+        Returns:
+            CharNGram, CharNGram vector build from a file.
+
+        Raises:
+            RuntimeError: If `file_path` contains invalid data.
+            ValueError: If `max_vectors` is invalid.
+            TypeError: If `max_vectors` is not type of integer.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> char_n_gram = text.CharNGram.from_file("/path/to/char_n_gram/file", max_vectors=None)
         """
 
@@ -66,13 +75,22 @@ class FastText(cde.FastText):
 
         Args:
             file_path (str): Path of the file that contains the vectors. The shuffix of pre-trained vector sets
-                must be `*.vec`.
+                must be `*.vec` .
             max_vectors (int, optional): This can be used to limit the number of pre-trained vectors loaded.
                 Most pre-trained vector sets are sorted in the descending order of word frequency. Thus, in
-                situations where the entire set doesn’t fit in memory, or is not needed for another reason,
-                passing max_vectors can limit the size of the loaded set (default=None, no limit).
+                situations where the entire set doesn't fit in memory, or is not needed for another reason,
+                passing `max_vectors` can limit the size of the loaded set. Default: None, no limit.
+
+        Returns:
+            FastText, FastText vector build from a file.
+
+        Raises:
+            RuntimeError: If `file_path` contains invalid data.
+            ValueError: If `max_vectors` is invalid.
+            TypeError: If `max_vectors` is not type of integer.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> fast_text = text.FastText.from_file("/path/to/fast_text/file", max_vectors=None)
         """
 
@@ -93,13 +111,22 @@ class GloVe(cde.GloVe):
 
         Args:
             file_path (str): Path of the file that contains the vectors. The format of pre-trained vector sets
-                must be `glove.6B.*.txt`.
+                must be `glove.6B.*.txt` .
             max_vectors (int, optional): This can be used to limit the number of pre-trained vectors loaded.
                 Most pre-trained vector sets are sorted in the descending order of word frequency. Thus, in
-                situations where the entire set doesn’t fit in memory, or is not needed for another reason,
-                passing max_vectors can limit the size of the loaded set (default=None, no limit).
+                situations where the entire set doesn't fit in memory, or is not needed for another reason,
+                passing `max_vectors` can limit the size of the loaded set. Default: None, no limit.
+
+        Returns:
+            GloVe, GloVe vector build from a file.
+
+        Raises:
+            RuntimeError: If `file_path` contains invalid data.
+            ValueError: If `max_vectors` is invalid.
+            TypeError: If `max_vectors` is not type of integer.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> glove = text.GloVe.from_file("/path/to/glove/file", max_vectors=None)
         """
 
@@ -109,7 +136,7 @@ class GloVe(cde.GloVe):
 
 class JiebaMode(IntEnum):
     """
-    An enumeration for :class:`mindspore.dataset.text.JiebaTokenizer`.
+    An enumeration for :class:`mindspore.dataset.text.JiebaTokenizer` .
 
     Possible enumeration values are: JiebaMode.MIX, JiebaMode.MP, JiebaMode.HMM.
 
@@ -211,16 +238,18 @@ class SentencePieceVocab:
             SentencePieceVocab, vocab built from the dataset.
 
         Examples:
-            >>> from mindspore.dataset.text import SentencePieceModel
+            >>> import mindspore.dataset as ds
+            >>> from mindspore.dataset.text import SentencePieceVocab, SentencePieceModel
             >>> dataset = ds.TextFileDataset("/path/to/sentence/piece/vocab/file", shuffle=False)
-            >>> vocab = text.SentencePieceVocab.from_dataset(dataset, ["text"], 5000, 0.9995,
-            ...                                              SentencePieceModel.UNIGRAM, {})
+            >>> vocab = SentencePieceVocab.from_dataset(dataset, ["text"], 5000, 0.9995,
+            ...                                         SentencePieceModel.UNIGRAM, {})
         """
 
         sentence_piece_vocab = cls()
-        sentence_piece_vocab.c_sentence_piece_vocab = dataset.build_sentencepiece_vocab(col_names, vocab_size,
-                                                                                        character_coverage,
-                                                                                        model_type, params)
+        # pylint: disable=protected-access
+        sentence_piece_vocab.c_sentence_piece_vocab = dataset._build_sentencepiece_vocab(col_names, vocab_size,
+                                                                                         character_coverage,
+                                                                                         model_type, params)
         return sentence_piece_vocab
 
     @classmethod
@@ -253,9 +282,9 @@ class SentencePieceVocab:
             SentencePieceVocab, vocab built from the file.
 
         Examples:
-            >>> from mindspore.dataset.text import SentencePieceModel
-            >>> vocab = text.SentencePieceVocab.from_file(["/path/to/sentence/piece/vocab/file"], 5000, 0.9995,
-            ...                                           SentencePieceModel.UNIGRAM, {})
+            >>> from mindspore.dataset.text import SentencePieceVocab, SentencePieceModel
+            >>> vocab = SentencePieceVocab.from_file(["/path/to/sentence/piece/vocab/file"], 5000, 0.9995,
+            ...                                      SentencePieceModel.UNIGRAM, {})
         """
 
         sentence_piece_vocab = cls()
@@ -275,10 +304,10 @@ class SentencePieceVocab:
             filename (str): The name of the file.
 
         Examples:
-            >>> from mindspore.dataset.text import SentencePieceModel
-            >>> vocab = text.SentencePieceVocab.from_file(["/path/to/sentence/piece/vocab/file"], 5000, 0.9995,
-            ...                                           SentencePieceModel.UNIGRAM, {})
-            >>> text.SentencePieceVocab.save_model(vocab, "./", "m.model")
+            >>> from mindspore.dataset.text import SentencePieceVocab, SentencePieceModel
+            >>> vocab = SentencePieceVocab.from_file(["/path/to/sentence/piece/vocab/file"], 5000, 0.9995,
+            ...                                      SentencePieceModel.UNIGRAM, {})
+            >>> SentencePieceVocab.save_model(vocab, "./", "m.model")
         """
 
         cde.SentencePieceVocab.save_model(vocab.c_sentence_piece_vocab, path, filename)
@@ -286,7 +315,7 @@ class SentencePieceVocab:
 
 class SPieceTokenizerLoadType(IntEnum):
     """
-    An enumeration for loading type of :class:`mindspore.dataset.text.SentencePieceTokenizer`.
+    An enumeration for loading type of :class:`mindspore.dataset.text.SentencePieceTokenizer` .
 
     Possible enumeration values are: SPieceTokenizerLoadType.FILE, SPieceTokenizerLoadType.MODEL.
 
@@ -300,7 +329,7 @@ class SPieceTokenizerLoadType(IntEnum):
 
 class SPieceTokenizerOutType(IntEnum):
     """
-    An enumeration for :class:`mindspore.dataset.text.SentencePieceTokenizer`.
+    An enumeration for :class:`mindspore.dataset.text.SentencePieceTokenizer` .
 
     Possible enumeration values are: SPieceTokenizerOutType.STRING, SPieceTokenizerOutType.INT.
 
@@ -327,10 +356,19 @@ class Vectors(cde.Vectors):
             file_path (str): Path of the file that contains the vectors.
             max_vectors (int, optional): This can be used to limit the number of pre-trained vectors loaded.
                 Most pre-trained vector sets are sorted in the descending order of word frequency. Thus, in
-                situations where the entire set doesn’t fit in memory, or is not needed for another reason,
-                passing max_vectors can limit the size of the loaded set (default=None, no limit).
+                situations where the entire set doesn't fit in memory, or is not needed for another reason,
+                passing `max_vectors` can limit the size of the loaded set. Default: None, no limit.
+
+        Returns:
+            Vectors, Vectors build from a file.
+
+        Raises:
+            RuntimeError: If `file_path` contains invalid data.
+            ValueError: If `max_vectors` is invalid.
+            TypeError: If `max_vectors` is not type of integer.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> vector = text.Vectors.from_file("/path/to/vectors/file", max_vectors=None)
         """
 
@@ -362,25 +400,27 @@ class Vocab:
         Args:
             dataset (Dataset): dataset to build vocab from.
             columns (list[str], optional): column names to get words from. It can be a list of column names.
-                (default=None).
+                Default: None.
             freq_range (tuple, optional): A tuple of integers (min_frequency, max_frequency). Words within the frequency
                 range would be kept. 0 <= min_frequency <= max_frequency <= total_words. min_frequency=0 is the same as
                 min_frequency=1. max_frequency > total_words is the same as max_frequency = total_words.
-                min_frequency/max_frequency can be None, which corresponds to 0/total_words separately
-                (default=None, all words are included).
+                min_frequency/max_frequency can be None, which corresponds to 0/total_words separately.
+                Default: None, all words are included.
             top_k (int, optional): top_k is greater than 0. Number of words to be built into vocab. top_k means most
-                frequent words are taken. top_k is taken after freq_range. If not enough top_k, all words will be taken
-                (default=None, all words are included).
+                frequent words are taken. top_k is taken after freq_range. If not enough top_k, all words will be taken.
+                Default: None, all words are included.
             special_tokens (list, optional):  A list of strings, each one is a special token. For example
-                special_tokens=["<pad>","<unk>"] (default=None, no special tokens will be added).
+                special_tokens=["<pad>","<unk>"]. Default: None, no special tokens will be added.
             special_first (bool, optional): Whether special_tokens will be prepended/appended to vocab. If
-                special_tokens is specified and special_first is set to True, special_tokens will be prepended
-                (default=True).
+                special_tokens is specified and special_first is set to True, special_tokens will be prepended.
+                Default: True.
 
         Returns:
             Vocab, Vocab object built from the dataset.
 
         Examples:
+            >>> import mindspore.dataset as ds
+            >>> import mindspore.dataset.text as text
             >>> dataset = ds.TextFileDataset("/path/to/sentence/piece/vocab/file", shuffle=False)
             >>> vocab = text.Vocab.from_dataset(dataset, "text", freq_range=None, top_k=None,
             ...                                 special_tokens=["<pad>", "<unk>"],
@@ -389,7 +429,8 @@ class Vocab:
         """
 
         vocab = cls()
-        vocab.c_vocab = dataset.build_vocab(columns, freq_range, top_k, special_tokens, special_first)
+        # pylint: disable=protected-access
+        vocab.c_vocab = dataset._build_vocab(columns, freq_range, top_k, special_tokens, special_first)
         return vocab
 
     @classmethod
@@ -401,14 +442,15 @@ class Vocab:
         Args:
             word_list (list): A list of string where each element is a word of type string.
             special_tokens (list, optional):  A list of strings, each one is a special token. For example
-                special_tokens=["<pad>","<unk>"] (default=None, no special tokens will be added).
+                special_tokens=["<pad>","<unk>"]. Default: None, no special tokens will be added.
             special_first (bool, optional): Whether special_tokens is prepended or appended to vocab. If special_tokens
-                is specified and special_first is set to True, special_tokens will be prepended (default=True).
+                is specified and special_first is set to True, special_tokens will be prepended. Default: True.
 
         Returns:
             Vocab, Vocab object built from the list.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> vocab = text.Vocab.from_list(["w1", "w2", "w3"], special_tokens=["<unk>"], special_first=True)
         """
 
@@ -427,18 +469,19 @@ class Vocab:
         Args:
             file_path (str): Path to the file which contains the vocab list.
             delimiter (str, optional): A delimiter to break up each line in file, the first element is taken to be
-                the word (default="", the whole line will be treated as a word).
-            vocab_size (int, optional): Number of words to read from file_path (default=None, all words are taken).
+                the word. Default: '', the whole line will be treated as a word.
+            vocab_size (int, optional): Number of words to read from file_path. Default: None, all words are taken.
             special_tokens (list, optional):  A list of strings, each one is a special token. For example
-                special_tokens=["<pad>","<unk>"] (default=None, no special tokens will be added).
+                special_tokens=["<pad>","<unk>"]. Default: None, no special tokens will be added.
             special_first (bool, optional): Whether special_tokens will be prepended/appended to vocab,
                 If special_tokens is specified and special_first is set to True,
-                special_tokens will be prepended (default=True).
+                special_tokens will be prepended. Default: True.
 
         Returns:
             Vocab, Vocab object built from the file.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> # Assume vocab file contains the following content:
             >>> # --- begin of file ---
             >>> # apple,apple2
@@ -476,6 +519,7 @@ class Vocab:
             Vocab, Vocab object built from the dict.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> vocab = text.Vocab.from_dict({"home": 3, "behind": 2, "the": 4, "world": 5, "<unk>": 6})
         """
 
@@ -491,6 +535,7 @@ class Vocab:
             A vocabulary consisting of word and id pairs.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> vocab = text.Vocab.from_list(["word_1", "word_2", "word_3", "word_4"])
             >>> vocabory_dict = vocab.vocab()
         """
@@ -510,6 +555,7 @@ class Vocab:
             The token id or list of token ids.
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> vocab = text.Vocab.from_list(["w1", "w2", "w3"], special_tokens=["<unk>"], special_first=True)
             >>> ids = vocab.tokens_to_ids(["w1", "w3"])
         """
@@ -533,6 +579,7 @@ class Vocab:
             The decoded token(s).
 
         Examples:
+            >>> import mindspore.dataset.text as text
             >>> vocab = text.Vocab.from_list(["w1", "w2", "w3"], special_tokens=["<unk>"], special_first=True)
             >>> token = vocab.ids_to_tokens(0)
         """
@@ -546,17 +593,18 @@ class Vocab:
 
 def to_bytes(array, encoding='utf8'):
     """
-    Convert NumPy array of `str` to array of `bytes` by encoding each element based on charset `encoding`.
+    Convert NumPy array of `str` to array of `bytes` by encoding each element based on charset `encoding` .
 
     Args:
         array (numpy.ndarray): Array of `str` type representing strings.
-        encoding (str): Indicating the charset for encoding (default='utf8').
+        encoding (str): Indicating the charset for encoding. Default: 'utf8'.
 
     Returns:
-        numpy.ndarray, NumPy array of `bytes`.
+        numpy.ndarray, NumPy array of `bytes` .
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
         >>>
         >>> data = np.array([["1", "2", "3"]], dtype=np.str_)
         >>> dataset = ds.NumpySlicesDataset(data, column_names=["text"])
@@ -572,17 +620,18 @@ def to_bytes(array, encoding='utf8'):
 
 def to_str(array, encoding='utf8'):
     """
-    Convert NumPy array of `bytes` to array of `str` by decoding each element based on charset `encoding`.
+    Convert NumPy array of `bytes` to array of `str` by decoding each element based on charset `encoding` .
 
     Args:
         array (numpy.ndarray): Array of `bytes` type representing strings.
-        encoding (str): Indicating the charset for decoding (default='utf8').
+        encoding (str): Indicating the charset for decoding. Default: 'utf8'.
 
     Returns:
-        numpy.ndarray, NumPy array of `str`.
+        numpy.ndarray, NumPy array of `str` .
 
     Examples:
         >>> import numpy as np
+        >>> import mindspore.dataset as ds
         >>>
         >>> data = np.array([["1", "2", "3"]], dtype=np.bytes_)
         >>> dataset = ds.NumpySlicesDataset(data, column_names=["text"])

mindspore/dataset/text/validators.py

@@ -27,6 +27,19 @@ from ..core.validator_helpers import parse_user_args, type_check, type_check_lis
     INT32_MAX, check_value, check_positive, check_pos_int32, check_filename, check_non_negative_int32
 
 
+def check_add_token(method):
+    """Wrapper method to check the parameters of add token."""
+
+    @wraps(method)
+    def new_method(self, *args, **kwargs):
+        [token, begin], _ = parse_user_args(method, *args, **kwargs)
+        type_check(token, (str,), "token")
+        type_check(begin, (bool,), "begin")
+        return method(self, *args, **kwargs)
+
+    return new_method
+
+
 def check_unique_list_of_words(words, arg_name):
     """Check that words is a list and each element is a str without any duplication"""
 
@@ -443,6 +456,18 @@ def check_ngram(method):
     return new_method
 
 
+def check_truncate(method):
+    """Wrapper method to check the parameters of number of truncate."""
+
+    @wraps(method)
+    def new_method(self, *args, **kwargs):
+        [max_seq_len], _ = parse_user_args(method, *args, **kwargs)
+        check_pos_int32(max_seq_len, "max_seq_len")
+        return method(self, *args, **kwargs)
+
+    return new_method
+
+
 def check_pair_truncate(method):
     """Wrapper method to check the parameters of number of pair truncate."""
 

mindspore/dataset/transforms/__init__.py

@@ -30,13 +30,15 @@ Note: Legacy c_transforms and py_transforms are deprecated but can still be impo
     from mindspore.dataset.transforms import c_transforms
     from mindspore.dataset.transforms import py_transforms
 
-See `Common Data Processing and Augmentation
-<https://www.mindspore.cn/tutorials/en/r1.10/beginner/transforms.html#common-transforms>`_ tutorial for more details.
+See `Common Transforms
+<https://www.mindspore.cn/tutorials/en/r2.0/beginner/transforms.html#common-transforms>`_ tutorial for more details.
 
 Descriptions of common data processing terms are as follows:
 
 - TensorOperation, the base class of all data processing operations implemented in C++.
 - PyTensorOperation, the base class of all data processing operations implemented in Python.
+
+Note: In eager mode, non-NumPy input is implicitly converted to NumPy format and sent to MindSpore.
 """
 from .. import vision
 from . import c_transforms

mindspore/dataset/transforms/c_transforms.py

@@ -142,7 +142,7 @@ class TypeCast(TensorOperation):
         TypeError: If `data_type` is not of type bool, int, float or string.
 
     Supported Platforms:
-        ``CPU`` ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -211,10 +211,10 @@ class Slice(TensorOperation):
                 `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`.
+            5.  :py:obj:`Ellipsis`: Slice the whole dimension, same result with `None` .
 
     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 int, list[int], :py:obj:`slice` , :py:obj:`None` or :py:obj:`Ellipsis` .
 
     Supported Platforms:
         ``CPU``
@@ -286,7 +286,7 @@ class Mask(TensorOperation):
         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.
         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.
@@ -375,10 +375,10 @@ class Concatenate(TensorOperation):
     Tensor operation that concatenates all columns into a single tensor.
 
     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).
+        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.
 
     Raises:
         TypeError: If `axis` is not of type int.
@@ -430,8 +430,7 @@ class Duplicate(TensorOperation):
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["x"])
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=c_transforms.Duplicate(),
         ...                                                 input_columns=["x"],
-        ...                                                 output_columns=["x", "y"],
-        ...                                                 column_order=["x", "y"])
+        ...                                                 output_columns=["x", "y"])
         >>> # Data after
         >>> # |  x      |  y      |
         >>> # +---------+---------+
@@ -477,8 +476,7 @@ class Unique(TensorOperation):
         >>> dataset = ds.NumpySlicesDataset(data, ["x"])
         >>> dataset = dataset.map(operations=c_transforms.Unique(),
         ...                       input_columns=["x"],
-        ...                       output_columns=["x", "y", "z"],
-        ...                       column_order=["x", "y", "z"])
+        ...                       output_columns=["x", "y", "z"])
         >>> # Data after
         >>> # |  x      |  y              |z        |
         >>> # +---------+-----------------+---------+
@@ -536,7 +534,7 @@ class RandomApply(TensorOperation):
 
     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.

mindspore/dataset/transforms/py_transforms.py

@@ -94,7 +94,7 @@ class OneHotOp(PyTensorOperation):
         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.)
+            Default: 0.0, means no smoothing is applied.
 
     Raises:
         TypeError: `num_classes` is not of type int.
@@ -260,7 +260,7 @@ class RandomApply(PyTensorOperation):
 
     Args:
         transforms (list): List of transformations to apply.
-        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.

mindspore/dataset/transforms/py_transforms_util.py

@@ -191,6 +191,7 @@ class FuncWrapper:
                 self.random = False
         except KeyError:
             self.random = True
+        self.logged_list_mixed_type_warning = False  # Warning for list mixed type result is not logged yet
 
     def __call__(self, *args):
         try:
@@ -198,6 +199,15 @@ class FuncWrapper:
         except Exception:
             result = ExceptionHandler(where="in map(or batch) worker and execute Python function")
             result.reraise()
+
+        # Check if result is list type, and mixed type warning for list type result has not been logged yet
+        if isinstance(result, list) and not self.logged_list_mixed_type_warning:
+            result0_type = type(result[0])
+            if not all((type(t) is result0_type) for t in result):  # pylint: disable=unidiomatic-typecheck
+                self.logged_list_mixed_type_warning = True
+                warn_msg = "All elements in returned list are not of the same type in Python function." + \
+                           " First element has type: " + str(result0_type)
+                logger.warning(warn_msg)
         return result
 
     def to_json(self):

mindspore/dataset/transforms/transforms.py

@@ -346,10 +346,10 @@ 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).
-        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): 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.
 
     Raises:
         TypeError: If `axis` is not of type int.
@@ -402,8 +402,7 @@ class Duplicate(TensorOperation):
         >>> numpy_slices_dataset = ds.NumpySlicesDataset(data, ["x"])
         >>> numpy_slices_dataset = numpy_slices_dataset.map(operations=transforms.Duplicate(),
         ...                                                 input_columns=["x"],
-        ...                                                 output_columns=["x", "y"],
-        ...                                                 column_order=["x", "y"])
+        ...                                                 output_columns=["x", "y"])
         >>> # Data after
         >>> # |  x      |  y      |
         >>> # +---------+---------+
@@ -514,7 +513,7 @@ class OneHot(TensorOperation):
         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.)
+            Default: 0.0, means no smoothing is applied.
 
     Raises:
         TypeError: `num_classes` is not of type int.
@@ -630,7 +629,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.
@@ -845,10 +844,10 @@ class Slice(TensorOperation):
                 `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`.
+            5.  :py:obj:`Ellipsis`: Slice the whole dimension, same result with `None` .
 
     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 int, list[int], :py:obj:`slice` , :py:obj:`None` or :py:obj:`Ellipsis` .
 
     Supported Platforms:
         ``CPU``
@@ -890,14 +889,14 @@ class TypeCast(TensorOperation):
         This operation supports running on Ascend or GPU platforms by Offload.
 
     Args:
-        data_type (Union[mindspore.dtype, numpy.dtype]): mindspore.dtype or numpy.dtype (e.g. :class:`numpy.float32`)
+        data_type (Union[mindspore.dtype, numpy.dtype]): mindspore.dtype or numpy.dtype (e.g. `numpy.float32`)
             to be cast to.
 
     Raises:
-        TypeError: If `data_type` is not of MindSpore data type bool, int, float, string or type :class:`numpy.dtype`.
+        TypeError: If `data_type` is not of MindSpore data type bool, int, float, string or type :class:`numpy.dtype` .
 
     Supported Platforms:
-        ``CPU`` ``Ascend`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
@@ -957,8 +956,7 @@ class Unique(TensorOperation):
         >>> dataset = ds.NumpySlicesDataset(data, ["x"])
         >>> dataset = dataset.map(operations=transforms.Unique(),
         ...                       input_columns=["x"],
-        ...                       output_columns=["x", "y", "z"],
-        ...                       column_order=["x", "y", "z"])
+        ...                       output_columns=["x", "y", "z"])
         >>> # Data after
         >>> # |  x      |  y              |z        |
         >>> # +---------+-----------------+---------+

mindspore/dataset/transforms/validators.py

@@ -245,7 +245,7 @@ def check_random_transform_ops(method):
 
 
 def check_transform_op_type(ind, op):
-    """Check the operator."""
+    """Check the operation."""
     # c_vision.HWC2CHW error
     # py_vision.HWC2CHW error
     if type(op) == type:  # pylint: disable=unidiomatic-typecheck
@@ -389,22 +389,22 @@ def check_type_cast(method):
 
 
 def deprecated_c_transforms(substitute_name=None, substitute_module=None):
-    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.transforms.c_transforms operator.
+    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.transforms.c_transforms operation.
 
     Args:
-        substitute_name (str, optional): The substitute name for deprecated operator.
-        substitute_module (str, optional): The substitute module for deprecated operator.
+        substitute_name (str, optional): The substitute name for deprecated operation.
+        substitute_module (str, optional): The substitute module for deprecated operation.
     """
     return deprecator_factory("1.8", "mindspore.dataset.transforms.c_transforms", "mindspore.dataset.transforms",
                               substitute_name, substitute_module)
 
 
 def deprecated_py_transforms(substitute_name=None, substitute_module=None):
-    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.transforms.py_transforms operator.
+    """Decorator for version 1.8 deprecation warning for legacy mindspore.dataset.transforms.py_transforms operation.
 
     Args:
-        substitute_name (str, optional): The substitute name for deprecated operator.
-        substitute_module (str, optional): The substitute module for deprecated operator.
+        substitute_name (str, optional): The substitute name for deprecated operation.
+        substitute_module (str, optional): The substitute module for deprecated operation.
     """
     return deprecator_factory("1.8", "mindspore.dataset.transforms.py_transforms", "mindspore.dataset.transforms",
                               substitute_name, substitute_module)

mindspore/dataset/utils/__init__.py

@@ -14,5 +14,6 @@
 # ==============================================================================
 """init file for MindData utils"""
 from .browse_dataset import imshow_det_bbox
+from .line_reader import LineReader
 
-__all__ = ["imshow_det_bbox"]
+__all__ = ["imshow_det_bbox", "LineReader"]