mindspore 1.10.0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/include/dataset/text.h

@@ -234,6 +234,36 @@ class SentencePieceVocab {
 
 // Transform operations for text
 namespace text {
+/// \brief Add token to beginning or end of sequence.
+class DATASET_API AddToken final : public TensorTransform {
+ public:
+  /// \brief Constructor.
+  /// \param[in] token The token to be added.
+  /// \param[in] begin Whether to insert token at start or end of sequence. Default: true.
+  /// \par Example
+  /// \code
+  ///     /* Define operations */
+  ///     auto add_token_op = text::AddToken(token='TOKEN', begin=True);
+  ///
+  ///     /* dataset is an instance of Dataset object */
+  ///     dataset = dataset->Map({add_token_op},   // operations
+  ///                            {"text"});       // input columns
+  /// \endcode
+  explicit AddToken(const std::string &token, bool begin = true);
+
+  /// \brief Destructor.
+  ~AddToken() override = default;
+
+ protected:
+  /// \brief Function to convert TensorTransform object into a TensorOperation object.
+  /// \return Shared pointer to TensorOperation object.
+  std::shared_ptr<TensorOperation> Parse() override;
+
+ private:
+  struct Data;
+  std::shared_ptr<Data> data_;
+};
+
 #ifndef _WIN32
 /// \brief Tokenize a scalar tensor of UTF-8 string by specific rules.
 /// \note BasicTokenizer is not supported on the Windows platform yet.
@@ -864,6 +894,35 @@ class DATASET_API ToVectors final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
+/// \brief Truncate the input sequence so that it does not exceed the maximum length.
+class DATASET_API Truncate final : public TensorTransform {
+ public:
+  /// \brief Constructor.
+  /// \param[in] max_seq_len Maximum allowable length.
+  /// \par Example
+  /// \code
+  ///     /* Define operations */
+  ///     auto truncate_op = text::Truncate(5);
+  ///
+  ///     /* dataset is an instance of Dataset object */
+  ///     dataset = dataset->Map({truncate_op},   // operations
+  ///                            {"text"});       // input columns
+  /// \endcode
+  explicit Truncate(int32_t max_seq_len);
+
+  /// \brief Destructor.
+  ~Truncate() = default;
+
+ protected:
+  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
+  /// \return Shared pointer to the TensorOperation object.
+  std::shared_ptr<TensorOperation> Parse() override;
+
+ private:
+  struct Data;
+  std::shared_ptr<Data> data_;
+};
+
 /// \brief Truncate a pair of rank-1 tensors such that the total length is less than max_length.
 class DATASET_API TruncateSequencePair final : public TensorTransform {
  public:

mindspore/include/dataset/vision.h

@@ -440,6 +440,20 @@ class DATASET_API CutOut final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
+/// \brief Encode the image as JPEG data.
+/// \param[in] image The image to be encoded.
+/// \param[out] output The Tensor data.
+/// \param[in] quality The quality for the output tensor, in range of [1, 100]. Default: 75.
+/// \return The status code.
+Status DATASET_API EncodeJpeg(const mindspore::MSTensor &image, mindspore::MSTensor *output, int quality = 75);
+
+/// \brief Encode the image as PNG data.
+/// \param[in] image The image to be encoded.
+/// \param[out] output The Tensor data.
+/// \param[in] compression_level The compression_level for encoding, in range of [0, 9]. Default: 6.
+/// \return The status code.
+Status DATASET_API EncodePng(const mindspore::MSTensor &image, mindspore::MSTensor *output, int compression_level = 6);
+
 /// \brief Apply histogram equalization on the input image.
 class DATASET_API Equalize final : public TensorTransform {
  public:
@@ -624,56 +638,6 @@ class DATASET_API NormalizePad final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
-/// \brief Pad the image according to padding parameters.
-class DATASET_API Pad final : public TensorTransform {
- public:
-  /// \brief Constructor.
-  /// \param[in] padding A vector representing the number of pixels to pad the image.
-  ///    If the vector has one value, it pads all sides of the image with that value.
-  ///    If the vector has two values, it pads left and top with the first and
-  ///    right and bottom with the second value.
-  ///    If the vector has four values, it pads left, top, right, and bottom with
-  ///    those values respectively.
-  /// \param[in] fill_value A vector representing the pixel intensity of the borders. Only valid if the
-  ///    padding_mode is BorderType.kConstant. If 1 value is provided, it is used for all RGB channels.
-  ///    If 3 values are provided, it is used to fill R, G, B channels respectively.
-  /// \param[in] padding_mode The method of padding (default=BorderType.kConstant).
-  ///    Can be any of
-  ///    [BorderType.kConstant, BorderType.kEdge, BorderType.kReflect, BorderType.kSymmetric]
-  ///    - BorderType.kConstant, means it fills the border with constant values
-  ///    - BorderType.kEdge, means it pads with the last value on the edge
-  ///    - BorderType.kReflect, means it reflects the values on the edge omitting the last value of edge
-  ///    - BorderType.kSymmetric, means it reflects the values on the edge repeating the last value of edge
-  /// \note The behavior when `padding` is a sequence of length 2 will change from padding left/top with
-  ///     the first value and right/bottom with the second, to padding left/right with the first one
-  ///     and top/bottom with the second in the future. Or you can pass in a 4-element sequence to specify
-  ///     left, top, right and bottom respectively.
-  /// \par Example
-  /// \code
-  ///     /* Define operations */
-  ///     auto decode_op = vision::Decode();
-  ///     auto pad_op = vision::Pad({10, 10, 10, 10}, {255, 255, 255});
-  ///
-  ///     /* dataset is an instance of Dataset object */
-  ///     dataset = dataset->Map({decode_op, pad_op},  // operations
-  ///                            {"image"});           // input columns
-  /// \endcode
-  explicit Pad(const std::vector<int32_t> &padding, const std::vector<uint8_t> &fill_value = {0},
-               BorderType padding_mode = BorderType::kConstant);
-
-  /// \brief Destructor.
-  ~Pad() = default;
-
- protected:
-  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
-  /// \return Shared pointer to TensorOperation object.
-  std::shared_ptr<TensorOperation> Parse() override;
-
- private:
-  struct Data;
-  std::shared_ptr<Data> data_;
-};
-
 /// \brief Pad the image to a fixed size.
 class DATASET_API PadToSize final : public TensorTransform {
  public:
@@ -977,8 +941,8 @@ class DATASET_API RandomCrop final : public TensorTransform {
   ///     If the size has 2 values, it should be (height, width).
   /// \param[in] padding A vector representing the number of pixels to pad the image.
   ///    If the vector has one value, it pads all sides of the image with that value.
-  ///    If the vector has two values, it pads left and top with the first and
-  ///    right and bottom with the second value.
+  ///    If the vector has two values, it pads left and right with the first and
+  ///    top and bottom with the second value.
   ///    If the vector has four values, it pads left, top, right, and bottom with
   ///    those values respectively.
   /// \param[in] pad_if_needed A boolean indicating that whether to pad the image
@@ -993,10 +957,6 @@ class DATASET_API RandomCrop final : public TensorTransform {
   ///   - BorderType::kReflect, Reflect the values on the edge omitting the last value of edge.
   ///   - BorderType::kSymmetric, Reflect the values on the edge repeating the last value of edge.
   /// \note If the input image is more than one, then make sure that the image size is the same.
-  /// \note The behavior when `padding` is a sequence of length 2 will change from padding left/top with
-  ///     the first value and right/bottom with the second, to padding left/right with the first one
-  ///     and top/bottom with the second in the future. Or you can pass in a 4-element sequence to specify
-  ///     left, top, right and bottom respectively.
   /// \par Example
   /// \code
   ///     /* Define operations */
@@ -1080,8 +1040,8 @@ class DATASET_API RandomCropWithBBox final : public TensorTransform {
   ///     If the size has 2 values, it should be (height, width).
   /// \param[in] padding A vector representing the number of pixels to pad the image
   ///    If the vector has one value, it pads all sides of the image with that value.
-  ///    If the vector has two values, it pads left and top with the first and
-  ///    right and bottom with the second value.
+  ///    If the vector has two values, it pads left and right with the first and
+  ///    top and bottom with the second value.
   ///    If the vector has four values, it pads left, top, right, and bottom with
   ///    those values respectively.
   /// \param[in] pad_if_needed A boolean indicating that whether to pad the image
@@ -1095,10 +1055,6 @@ class DATASET_API RandomCropWithBBox final : public TensorTransform {
   ///   - BorderType::kEdge, Fill the border with the last value on the edge.
   ///   - BorderType::kReflect, Reflect the values on the edge omitting the last value of edge.
   ///   - BorderType::kSymmetric, Reflect the values on the edge repeating the last value of edge.
-  /// \note The behavior when `padding` is a sequence of length 2 will change from padding left/top with
-  ///     the first value and right/bottom with the second, to padding left/right with the first one
-  ///     and top/bottom with the second in the future. Or you can pass in a 4-element sequence to specify
-  ///     left, top, right and bottom respectively.
   /// \par Example
   /// \code
   ///     /* Define operations */
@@ -1711,36 +1667,24 @@ class DATASET_API RandomVerticalFlipWithBBox final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
-/// \brief Rescale the pixel value of input image.
-class DATASET_API Rescale final : public TensorTransform {
- public:
-  /// \brief Constructor.
-  /// \param[in] rescale Rescale factor.
-  /// \param[in] shift Shift factor.
-  /// \par Example
-  /// \code
-  ///     /* Define operations */
-  ///     auto decode_op = vision::Decode();
-  ///     auto rescale_op = vision::Rescale(1.0, 0.0);
-  ///
-  ///     /* dataset is an instance of Dataset object */
-  ///     dataset = dataset->Map({decode_op, rescale_op},  // operations
-  ///                            {"image"});               // input columns
-  /// \endcode
-  Rescale(float rescale, float shift);
-
-  /// \brief Destructor.
-  ~Rescale() = default;
-
- protected:
-  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
-  /// \return Shared pointer to TensorOperation object.
-  std::shared_ptr<TensorOperation> Parse() override;
-
- private:
-  struct Data;
-  std::shared_ptr<Data> data_;
-};
+/// \brief Reads a file in binary mode.
+/// \param[in] filename The path to the file to be read.
+/// \param[out] output The binary data.
+/// \return The status code.
+Status DATASET_API ReadFile(const std::string &filename, mindspore::MSTensor *output);
+
+/// \brief Read a image file and decode it into one or three channels data.
+/// \param[in] filename The path to the file to be read.
+/// \param[out] output The Tensor data.
+/// \param[in] mode The read mode used for optionally converting the image, can be one of
+///    [ImageReadMode::kUNCHANGED, ImageReadMode::kGRAYSCALE, ImageReadMode::kCOLOR]. Default:
+///    ImageReadMode::kUNCHANGED.
+///    - ImageReadMode::kUNCHANGED, remain the output in the original format.
+///    - ImageReadMode::kGRAYSCALE, convert the output into one channel grayscale data.
+///    - ImageReadMode::kCOLOR, convert the output into three channels RGB color data.
+/// \return The status code.
+Status DATASET_API ReadImage(const std::string &filename, mindspore::MSTensor *output,
+                             ImageReadMode mode = ImageReadMode::kUNCHANGED);
 
 /// \brief Crop the given image and zoom to the specified size.
 class DATASET_API ResizedCrop final : public TensorTransform {
@@ -1943,31 +1887,6 @@ class DATASET_API Solarize final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
-/// \brief Swap the red and blue channels of the input image.
-class DATASET_API SwapRedBlue final : public TensorTransform {
- public:
-  /// \brief Constructor.
-  /// \par Example
-  /// \code
-  ///     /* Define operations */
-  ///     auto decode_op = vision::Decode();
-  ///     auto swap_red_blue_op = vision::SwapRedBlue();
-  ///
-  ///     /* dataset is an instance of Dataset object */
-  ///     dataset = dataset->Map({decode_op, swap_red_blue_op},  // operations
-  ///                            {"image"});                     // input columns
-  /// \endcode
-  SwapRedBlue();
-
-  /// \brief Destructor.
-  ~SwapRedBlue() = default;
-
- protected:
-  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
-  /// \return Shared pointer to TensorOperation object.
-  std::shared_ptr<TensorOperation> Parse() override;
-};
-
 /// \brief Divide the pixel values by 255 and convert from HWC format to CHW format with required datatype.
 class DATASET_API ToTensor final : public TensorTransform {
  public:
@@ -2128,6 +2047,26 @@ class DATASET_API VerticalFlip final : public TensorTransform {
   /// \return Shared pointer to TensorOperation object.
   std::shared_ptr<TensorOperation> Parse() override;
 };
+
+/// \brief Write the one dimension uint8 data into a file using binary mode.
+/// \param[in] filename The path to the file to be written.
+/// \param[in] data The tensor data.
+/// \return The status code.
+Status DATASET_API WriteFile(const std::string &filename, const mindspore::MSTensor &data);
+
+/// \brief Write the image data into a JPEG file.
+/// \param[in] filename The path to the file to be written.
+/// \param[in] image The data tensor.
+/// \param[in] quality The quality for JPEG file, in range of [1, 100]. Default: 75.
+/// \return The status code.
+Status DATASET_API WriteJpeg(const std::string &filename, const mindspore::MSTensor &image, int quality = 75);
+
+/// \brief Write the image into a PNG file.
+/// \param[in] filename The path to the file to be written.
+/// \param[in] image The data tensor.
+/// \param[in] compression_level The compression level for PNG file, in range of [0, 9]. Default: 6.
+/// \return The status code.
+Status DATASET_API WritePng(const std::string &filename, const mindspore::MSTensor &image, int compression_level = 6);
 }  // namespace vision
 }  // namespace dataset
 }  // namespace mindspore

mindspore/include/dataset/vision_lite.h

@@ -268,6 +268,52 @@ class DATASET_API Normalize final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
+/// \brief Pad the image according to padding parameters.
+class DATASET_API Pad final : public TensorTransform {
+ public:
+  /// \brief Constructor.
+  /// \param[in] padding A vector representing the number of pixels to pad the image.
+  ///    If the vector has one value, it pads all sides of the image with that value.
+  ///    If the vector has two values, it pads left and right with the first and
+  ///    top and bottom with the second value.
+  ///    If the vector has four values, it pads left, top, right, and bottom with
+  ///    those values respectively.
+  /// \param[in] fill_value A vector representing the pixel intensity of the borders. Only valid if the
+  ///    padding_mode is BorderType.kConstant. If 1 value is provided, it is used for all RGB channels.
+  ///    If 3 values are provided, it is used to fill R, G, B channels respectively.
+  /// \param[in] padding_mode The method of padding (default=BorderType.kConstant).
+  ///    Can be any of
+  ///    [BorderType.kConstant, BorderType.kEdge, BorderType.kReflect, BorderType.kSymmetric]
+  ///    - BorderType.kConstant, means it fills the border with constant values
+  ///    - BorderType.kEdge, means it pads with the last value on the edge
+  ///    - BorderType.kReflect, means it reflects the values on the edge omitting the last value of edge
+  ///    - BorderType.kSymmetric, means it reflects the values on the edge repeating the last value of edge
+  /// \par Example
+  /// \code
+  ///     /* Define operations */
+  ///     auto decode_op = vision::Decode();
+  ///     auto pad_op = vision::Pad({10, 10, 10, 10}, {255, 255, 255});
+  ///
+  ///     /* dataset is an instance of Dataset object */
+  ///     dataset = dataset->Map({decode_op, pad_op},  // operations
+  ///                            {"image"});           // input columns
+  /// \endcode
+  explicit Pad(const std::vector<int32_t> &padding, const std::vector<uint8_t> &fill_value = {0},
+               BorderType padding_mode = BorderType::kConstant);
+
+  /// \brief Destructor.
+  ~Pad() = default;
+
+ protected:
+  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
+  /// \return Shared pointer to TensorOperation object.
+  std::shared_ptr<TensorOperation> Parse() override;
+
+ private:
+  struct Data;
+  std::shared_ptr<Data> data_;
+};
+
 /// \brief Apply a Random Affine transformation on the input image in RGB or Greyscale mode.
 class DATASET_API RandomAffine final : public TensorTransform {
  public:
@@ -319,6 +365,37 @@ class DATASET_API RandomAffine final : public TensorTransform {
   std::shared_ptr<Data> data_;
 };
 
+/// \brief Rescale the pixel value of input image.
+class DATASET_API Rescale final : public TensorTransform {
+ public:
+  /// \brief Constructor.
+  /// \param[in] rescale Rescale factor.
+  /// \param[in] shift Shift factor.
+  /// \par Example
+  /// \code
+  ///     /* Define operations */
+  ///     auto decode_op = vision::Decode();
+  ///     auto rescale_op = vision::Rescale(1.0, 0.0);
+  ///
+  ///     /* dataset is an instance of Dataset object */
+  ///     dataset = dataset->Map({decode_op, rescale_op},  // operations
+  ///                            {"image"});               // input columns
+  /// \endcode
+  Rescale(float rescale, float shift);
+
+  /// \brief Destructor.
+  ~Rescale() = default;
+
+ protected:
+  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
+  /// \return Shared pointer to TensorOperation object.
+  std::shared_ptr<TensorOperation> Parse() override;
+
+ private:
+  struct Data;
+  std::shared_ptr<Data> data_;
+};
+
 /// \brief Resize the input image to the given size.
 class DATASET_API Resize final : public TensorTransform {
  public:
@@ -517,6 +594,31 @@ class DATASET_API Rotate final : public TensorTransform {
   struct Data;
   std::shared_ptr<Data> data_;
 };
+
+/// \brief Swap the red and blue channels of the input image.
+class DATASET_API SwapRedBlue final : public TensorTransform {
+ public:
+  /// \brief Constructor.
+  /// \par Example
+  /// \code
+  ///     /* Define operations */
+  ///     auto decode_op = vision::Decode();
+  ///     auto swap_red_blue_op = vision::SwapRedBlue();
+  ///
+  ///     /* dataset is an instance of Dataset object */
+  ///     dataset = dataset->Map({decode_op, swap_red_blue_op},  // operations
+  ///                            {"image"});                     // input columns
+  /// \endcode
+  SwapRedBlue();
+
+  /// \brief Destructor.
+  ~SwapRedBlue() = default;
+
+ protected:
+  /// \brief The function to convert a TensorTransform object into a TensorOperation object.
+  /// \return Shared pointer to TensorOperation object.
+  std::shared_ptr<TensorOperation> Parse() override;
+};
 }  // namespace vision
 }  // namespace dataset
 }  // namespace mindspore

mindspore/log.py

@@ -37,18 +37,18 @@ _setup_logger_lock = threading.Lock()
 
 # When getting the logger, Used to check whether
 # the logger already exists
-_global_logger = None
+GLOBAL_LOGGER = None
 
 # The flag for enable console output
-_std_on = '1'
+STD_ON = '1'
 # The flag for disable console output
-_std_off = '0'
+STD_OFF = '0'
 # Rotating max bytes, default is 50M
-_logger_def_max_bytes = '52428800'
+MAX_BYTES = '52428800'
 # Rotating backup count, default is 30
-_logger_def_backup_count = '30'
+BACKUP_COUNT = '30'
 # The default log level
-_logger_def_level = '2'
+LOGGER_LEVEL = '2'
 
 # Log level name and level mapping
 _name_to_level = {
@@ -155,8 +155,8 @@ def _get_logger():
     Returns:
         Logger, a logger.
     """
-    if _global_logger:
-        return _global_logger
+    if GLOBAL_LOGGER:
+        return GLOBAL_LOGGER
 
     kwargs = _get_env_config()
     _verify_config(kwargs)
@@ -180,11 +180,11 @@ def _adapt_cfg(kwargs):
     Returns:
         Dict, the input parameter dictionary.
     """
-    kwargs['level'] = _gloglevel_to_name.get(kwargs.get('level', _logger_def_level))
-    kwargs['stderr_level'] = _gloglevel_to_name.get(kwargs.get('stderr_level', _logger_def_level))
-    kwargs['console'] = not kwargs.get('console') == _std_off
-    kwargs['maxBytes'] = int(kwargs.get('maxBytes', _logger_def_max_bytes))
-    kwargs['backupCount'] = int(kwargs.get('backupCount', _logger_def_backup_count))
+    kwargs['level'] = _gloglevel_to_name.get(kwargs.get('level', LOGGER_LEVEL))
+    kwargs['stderr_level'] = _gloglevel_to_name.get(kwargs.get('stderr_level', LOGGER_LEVEL))
+    kwargs['console'] = not kwargs.get('console') == STD_OFF
+    kwargs['maxBytes'] = int(kwargs.get('maxBytes', MAX_BYTES))
+    kwargs['backupCount'] = int(kwargs.get('backupCount', BACKUP_COUNT))
     return kwargs
 
 
@@ -279,7 +279,7 @@ def _check_directory_by_regular(target, reg=None, flag=re.ASCII, prim_name=None)
     if not isinstance(target, str):
         raise ValueError("The directory {} must be string, but got {}, please check it".format(target, type(target)))
     if reg is None:
-        reg = r"^[\/0-9a-zA-Z\_\-\.\:\\]+$"
+        reg = r"^[\/0-9a-zA-Z@\_\-\.\:\\]+$"
     if re.match(reg, target, flag) is None:
         prim_name = f'in `{prim_name}`' if prim_name else ""
         raise ValueError("'{}' {} is illegal, it should be match regular'{}' by flag'{}'".format(
@@ -335,29 +335,29 @@ def _verify_config(kwargs):
     file_path = kwargs.get('filepath', None)
 
     if console is not None:
-        if not console.isdigit() or console not in (_std_off, _std_on):
+        if not console.isdigit() or console not in (STD_OFF, STD_ON):
             raise ValueError(f'Incorrect value, the value of {_confmap_dict["console"]} must be 0 or 1, '
                              f'but got {console}.')
 
-        if console == _std_off and not file_path:
+        if console == STD_OFF and not file_path:
             raise ValueError(f'When {_confmap_dict["console"]} is set to 0, the directory of saving log '
                              f'{_confmap_dict["filepath"]} must be set, but got it empty.')
 
         # Check the input value of filepath
-        if console == _std_off and file_path is not None:
+        if console == STD_OFF and file_path is not None:
             file_real_path = os.path.realpath(file_path)
             if not os.path.exists(file_real_path):
                 _make_directory(file_real_path)
         # Check the input value of maxBytes
         max_bytes = kwargs.get('maxBytes', None)
-        if console == _std_off and max_bytes is not None:
+        if console == STD_OFF and max_bytes is not None:
             if not max_bytes.isdigit():
                 raise ValueError(f'Incorrect value, the value of {_confmap_dict["maxBytes"]} must be positive integer. '
                                  f'But got {_confmap_dict["maxBytes"]}:{max_bytes}.')
 
         # Check the input value of backupCount
         backup_count = kwargs.get('backupCount', None)
-        if console == _std_off and backup_count is not None:
+        if console == STD_OFF and backup_count is not None:
             if not backup_count.isdigit():
                 raise ValueError(f'Incorrect value, the value of {_confmap_dict["backupCount"]} must be positive '
                                  f'integer. But got {_confmap_dict["backupCount"]}:{backup_count}')
@@ -404,10 +404,10 @@ def get_log_config():
     handler = logger.handlers[0]
     config_dict = {}
     config_dict['GLOG_v'] = get_level()
-    config_dict['GLOG_logtostderr'] = _std_on
+    config_dict['GLOG_logtostderr'] = STD_ON
 
     if handler.name == 'FileHandler':
-        config_dict['GLOG_logtostderr'] = _std_off
+        config_dict['GLOG_logtostderr'] = STD_OFF
         # Separating file path and name
         file_path_and_name = os.path.split(handler.baseFilename)
         config_dict['GLOG_log_dir'] = file_path_and_name[0]
@@ -532,12 +532,12 @@ def _setup_logger(kwargs):
     pid = str(os.getpid())
     log_name = 'mindspore.log.' + pid
 
-    global _global_logger
+    global GLOBAL_LOGGER
 
     _setup_logger_lock.acquire()
     try:
-        if _global_logger:
-            return _global_logger
+        if GLOBAL_LOGGER:
+            return GLOBAL_LOGGER
 
         logger = logging.getLogger(name=f'{sub_module}.{log_name}')
         # Override findCaller on the logger, Support for getting log record
@@ -569,9 +569,9 @@ def _setup_logger(kwargs):
             logfile_handler = _MultiCompatibleRotatingFileHandler(
                 filename=file_name,
                 # Rotating max bytes, default is 50M
-                maxBytes=kwargs.get('maxBytes', _logger_def_max_bytes),
+                maxBytes=kwargs.get('maxBytes', MAX_BYTES),
                 # Rotating backup count, default is 30
-                backupCount=kwargs.get('backupCount', _logger_def_backup_count),
+                backupCount=kwargs.get('backupCount', BACKUP_COUNT),
                 encoding='utf8'
             )
             logfile_handler.name = 'FileHandler'
@@ -589,11 +589,11 @@ def _setup_logger(kwargs):
             console_handler.setLevel(kwargs.get('stderr_level', logging.WARNING))
             logger.addHandler(console_handler)
 
-        _global_logger = logger
+        GLOBAL_LOGGER = logger
 
     finally:
         _setup_logger_lock.release()
-    return _global_logger
+    return GLOBAL_LOGGER
 
 
 class _LogActionOnce:

mindspore/mindrecord/common/exceptions.py

@@ -80,8 +80,7 @@ class MindRecordException(Exception):
         """Initialize an error which may occurs in mindrecord."""
         super(MindRecordException, self).__init__()
         class_name = self.__class__.__name__
-        error_item = EXCEPTIONS[class_name] if class_name in EXCEPTIONS \
-            else EXCEPTIONS['UnknownError']
+        error_item = EXCEPTIONS.get(class_name) if class_name in EXCEPTIONS else EXCEPTIONS.get('UnknownError')
         self._error_msg = error_item[1]
         self._error_code = MindRecordException.transform_error_code(error_item[0])
 
@@ -123,8 +122,7 @@ class MindRecordException(Exception):
         runtime = LogRuntime.RT_HOST
         error_code_type = ErrorCodeType.ERROR_CODE
         error_level = ErrorLevel.COMMON_LEVEL
-        exception_no_range_per_module = 100
-        mod_id = int(exception_no / exception_no_range_per_module) + 1
+        mod_id = int(exception_no / 100) + 1
         error_code = (((0xFF & runtime) << 30)
                       | ((0xFF & error_code_type) << 28)
                       | ((0xFF & error_level) << 25)

mindspore/mindrecord/filereader.py

@@ -43,7 +43,7 @@ class FileReader:
         operator (int, optional): Reserved parameter for operators. Default: None.
 
     Raises:
-        ParamValueError: If `file_name`, `num_consumer` or `columns` is invalid.
+        ParamValueError: If `file_name` , `num_consumer` or `columns` is invalid.
 
     Examples:
         >>> from mindspore.mindrecord import FileReader
@@ -100,3 +100,21 @@ class FileReader:
     def close(self):
         """Stop reader worker and close file."""
         self._reader.close()
+
+    def schema(self):
+        """
+        Get the schema of the MindRecord.
+
+        Returns:
+            dict, the schema info.
+        """
+        return self._header.schema
+
+    def len(self):
+        """
+        Get the number of the samples in MindRecord.
+
+        Returns:
+            int, the number of the samples in MindRecord.
+        """
+        return self._reader.len()