mindspore 2.4.0__cp310-cp310-macosx_10_15_x86_64.whl

mindspore/include/c_api/types_c.h

@@ -0,0 +1,67 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MINDSPORE_INCLUDE_C_API_TYPES_C_H
+#define MINDSPORE_INCLUDE_C_API_TYPES_C_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef MS_API
+#ifdef _WIN32
+#define MS_API __declspec(dllexport)
+#else
+#define MS_API __attribute__((visibility("default")))
+#endif
+#endif
+
+typedef enum MSModelType {
+  kMSModelTypeMindIR = 0,
+  // insert new data type here
+  kMSModelTypeInvalid = 0xFFFFFFFF
+} MSModelType;
+
+typedef enum MSDeviceType {
+  kMSDeviceTypeCPU = 0,
+  kMSDeviceTypeGPU,
+  kMSDeviceTypeKirinNPU,
+  // add new type here
+  kMSDeviceTypeInvalid = 100,
+} MSDeviceType;
+
+typedef enum MSOptimizationLevel {
+  /** Do not change */
+  kMSKO0 = 0,
+  /** Cast network to float16, keep batchnorm and loss in float32 */
+  kMSKO2 = 2,
+  /** Cast network to float16, including bacthnorm */
+  kMSKO3 = 3,
+  /** Choose optimization based on device */
+  kMSKAUTO = 4,
+  kMSKOPTIMIZATIONTYPE = 0xFFFFFFFF
+} MSOptimizationLevel;
+
+typedef enum MSQuantizationType {
+  kMSNO_QUANT = 0,
+  kMSWEIGHT_QUANT = 1,
+  kMSFULL_QUANT = 2,
+  kMSUNKNOWN_QUANT_TYPE = 0xFFFFFFFF
+} MSQuantizationType;
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_INCLUDE_C_API_TYPES_C_H

mindspore/include/dataset/config.h

@@ -0,0 +1,163 @@
+/**
+ * Copyright 2020-2024 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MINDSPORE_CCSRC_MINDDATA_DATASET_INCLUDE_DATASET_CONFIG_H
+#define MINDSPORE_CCSRC_MINDDATA_DATASET_INCLUDE_DATASET_CONFIG_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "include/api/dual_abi_helper.h"
+#include "include/api/visible.h"
+
+namespace mindspore {
+namespace dataset {
+// Config operations for setting and getting the configuration.
+namespace config {
+/// \brief A function to set the seed to be used in any random generator. This is used to produce deterministic results.
+/// \param[in] seed The default seed to be used.
+/// \return The seed is set successfully or not.
+/// \par Example
+/// \code
+///     // Set a new global configuration value for the seed value.
+///     // Operations with randomness will use the seed value to generate random values.
+///     bool rc = config::set_seed(5);
+/// \endcode
+bool DATASET_API set_seed(int32_t seed);
+
+/// \brief A function to get the seed.
+/// \return The seed set in the configuration.
+/// \par Example
+/// \code
+///     // Get the global configuration of seed.
+///     // If set_seed() is never called before, the default value(std::mt19937::default_seed) will be returned.
+///     uint32_t seed = config::get_seed();
+/// \endcode
+uint32_t DATASET_API get_seed();
+
+/// \brief A function to set the number of rows to be prefetched.
+/// \param[in] prefetch_size Total number of rows to be prefetched.
+/// \return The prefetch size is set successfully or not.
+/// \par Example
+/// \code
+///     // Set a new global configuration value for the prefetch size.
+///     bool rc = config::set_prefetch_size(1000);
+/// \endcode
+bool DATASET_API set_prefetch_size(int32_t prefetch_size);
+
+/// \brief A function to get the prefetch size in number of rows.
+/// \return Total number of rows to be prefetched.
+/// \par Example
+/// \code
+///     // Get the global configuration of prefetch size.
+///     // If set_prefetch_size() is never called before, the default value(16) will be returned.
+///     int32_t prefetch_size = config::get_prefetch_size();
+/// \endcode
+int32_t DATASET_API get_prefetch_size();
+
+/// \brief A function to set the default number of parallel workers.
+/// \param[in] num_parallel_workers Number of parallel workers to be used as the default for each operation.
+/// \return The workers is set successfully or not.
+/// \par Example
+/// \code
+///     // Set a new global configuration value for the number of parallel workers.
+///     // Now parallel dataset operations will run with 16 workers.
+///     bool rc = config::set_num_parallel_workers(16);
+/// \endcode
+bool DATASET_API set_num_parallel_workers(int32_t num_parallel_workers);
+
+/// \brief A function to get the default number of parallel workers.
+/// \return Number of parallel workers to be used as the default for each operation.
+/// \par Example
+/// \code
+///     // Get the global configuration of parallel workers.
+///     // If set_num_parallel_workers() is never called before, the default value(8) will be returned.
+///     int32_t parallel_workers = config::get_num_parallel_workers();
+/// \endcode
+int32_t DATASET_API get_num_parallel_workers();
+
+/// \brief A function to set the default interval (in milliseconds) for monitor sampling.
+/// \param[in] interval Interval (in milliseconds) to be used for performance monitor sampling.
+/// \return The sampling interval is set successfully or not.
+/// \par Example
+/// \code
+///     // Set a new global configuration value for the monitor sampling interval.
+///     bool rc = config::set_monitor_sampling_interval(100);
+/// \endcode
+bool DATASET_API set_monitor_sampling_interval(int32_t interval);
+
+/// \brief A function to get the default interval of performance monitor sampling.
+/// \return Interval (in milliseconds) for performance monitor sampling.
+/// \par Example
+/// \code
+///     // Get the global configuration of monitor sampling interval.
+///     // If set_monitor_sampling_interval() is never called before, the default value(1000) will be returned.
+///     int32_t sampling_interval = config::get_monitor_sampling_interval();
+/// \endcode
+int32_t DATASET_API get_monitor_sampling_interval();
+
+/// \brief A function to set the default timeout (in seconds) for DSWaitedCallback. In case of a deadlock, the wait
+///    function will exit after the timeout period.
+/// \param[in] timeout Timeout (in seconds) to be used to end the wait in DSWaitedCallback in case of a deadlock.
+/// \return The callback timeout is set successfully or not.
+/// \par Example
+/// \code
+///     // Set a new global configuration value for the timeout value.
+///     bool rc = config::set_callback_timeout(100);
+/// \endcode
+bool DATASET_API set_callback_timeout(int32_t timeout);
+
+/// \brief A function to get the default timeout for DSWaitedCallback. In case of a deadback, the wait function
+///    will exit after the timeout period.
+/// \return The duration in seconds.
+/// \par Example
+/// \code
+///     // Get the global configuration of callback timeout.
+///     // If set_callback_timeout() is never called before, the default value(60) will be returned.
+///     int32_t callback_timeout = config::get_callback_timeout();
+/// \endcode
+int32_t DATASET_API get_callback_timeout();
+
+/// \brief A function to load the configuration from a file.
+/// \param[in] file Path of the configuration file to be loaded.
+/// \return The config file is loaded successfully or not.
+/// \note The reason for using this API is that std::string will be constrained by the
+///    compiler option '_GLIBCXX_USE_CXX11_ABI' while char is free of this restriction.
+///    Check API `mindspore::dataset::config::load(const std::string &file)` and find more usage.
+bool DATASET_API load(const std::vector<char> &file);
+
+/// \brief A function to load the configuration from a file.
+/// \param[in] file Path of the configuration file to be loaded.
+/// \return The config file is loaded successfully or not.
+/// \par Example
+/// \code
+///     // Set new default configuration according to values in the configuration file.
+///     // example config file:
+///     // {
+///     //     "logFilePath": "/tmp",
+///     //     "numParallelWorkers": 4,
+///     //     "seed": 5489,
+///     //     "monitorSamplingInterval": 30
+///     // }
+///     std::string config_file = "/path/to/config/file";
+///     bool rc = config::load(config_file);
+/// \endcode
+inline bool DATASET_API load(const std::string &file) { return load(StringToChar(file)); }
+}  // namespace config
+}  // namespace dataset
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_MINDDATA_DATASET_INCLUDE_DATASET_CONFIG_H

mindspore/include/dataset/constants.h

@@ -0,0 +1,363 @@
+/**
+ * Copyright 2020-2024 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MINDSPORE_CCSRC_MINDDATA_DATASET_INCLUDE_DATASET_CONSTANTS_H_
+#define MINDSPORE_CCSRC_MINDDATA_DATASET_INCLUDE_DATASET_CONSTANTS_H_
+
+#include <cstdint>
+#include <limits>
+#include <random>
+
+#include "include/api/visible.h"
+
+namespace mindspore {
+namespace dataset {
+// Various type defines for convenience
+using uchar = unsigned char;
+using dsize_t = int64_t;
+
+/// \brief The modulation in Flanger
+enum class DATASET_API Modulation {
+  kSinusoidal = 0,  ///< Use sinusoidal modulation.
+  kTriangular = 1   ///< Use triangular modulation.
+};
+
+/// \brief The interpolation in Flanger
+enum class DATASET_API Interpolation {
+  kLinear = 0,    ///< Use linear for delay-line interpolation.
+  kQuadratic = 1  ///< Use quadratic for delay-line interpolation.
+};
+
+/// \brief The dataset auto augment policy in AutoAugment
+enum class DATASET_API AutoAugmentPolicy {
+  kImageNet = 0,  ///< AutoAugment policy learned on the ImageNet dataset.
+  kCifar10 = 1,   ///< AutoAugment policy learned on the Cifar10 dataset.
+  kSVHN = 2       ///< AutoAugment policy learned on the SVHN dataset.
+};
+
+/// \brief The color conversion code
+enum class DATASET_API ConvertMode {
+  COLOR_BGR2BGRA = 0,                 ///< Add alpha channel to BGR image.
+  COLOR_RGB2RGBA = COLOR_BGR2BGRA,    ///< Add alpha channel to RGB image.
+  COLOR_BGRA2BGR = 1,                 ///< Remove alpha channel to BGR image.
+  COLOR_RGBA2RGB = COLOR_BGRA2BGR,    ///< Remove alpha channel to RGB image.
+  COLOR_BGR2RGBA = 2,                 ///< Convert BGR image to RGBA image.
+  COLOR_RGB2BGRA = COLOR_BGR2RGBA,    ///< Convert RGB image to BGRA image.
+  COLOR_RGBA2BGR = 3,                 ///< Convert RGBA image to BGR image.
+  COLOR_BGRA2RGB = COLOR_RGBA2BGR,    ///< Convert BGRA image to RGB image.
+  COLOR_BGR2RGB = 4,                  ///< Convert BGR image to RGB image.
+  COLOR_RGB2BGR = COLOR_BGR2RGB,      ///< Convert RGB image to BGR image.
+  COLOR_BGRA2RGBA = 5,                ///< Convert BGRA image to RGBA image.
+  COLOR_RGBA2BGRA = COLOR_BGRA2RGBA,  ///< Convert RGBA image to BGRA image.
+  COLOR_BGR2GRAY = 6,                 ///< Convert BGR image to GRAY image.
+  COLOR_RGB2GRAY = 7,                 ///< Convert RGB image to GRAY image.
+  COLOR_GRAY2BGR = 8,                 ///< Convert GRAY image to BGR image.
+  COLOR_GRAY2RGB = COLOR_GRAY2BGR,    ///< Convert GRAY image to RGB image.
+  COLOR_GRAY2BGRA = 9,                ///< Convert GRAY image to BGRA image.
+  COLOR_GRAY2RGBA = COLOR_GRAY2BGRA,  ///< Convert GRAY image to RGBA image.
+  COLOR_BGRA2GRAY = 10,               ///< Convert BGRA image to GRAY image.
+  COLOR_RGBA2GRAY = 11                ///< Convert RGBA image to GRAY image.
+};
+
+/// \brief The mode for reading a image file.
+enum class DATASET_API ImageReadMode {
+  kUNCHANGED = 0,  ///< Remain the output in the original format.
+  kGRAYSCALE = 1,  ///< Convert the output into one channel grayscale data.
+  kCOLOR = 2,      ///< Convert the output into three channels RGB color data.
+};
+
+// \brief Possible density function in Dither.
+enum DATASET_API DensityFunction {
+  kTPDF = 0,  ///< Use triangular probability density function.
+  kRPDF = 1,  ///< Use rectangular probability density function.
+  kGPDF = 2   ///< Use gaussian probability density function.
+};
+
+/// \brief Values of norm in CreateDct.
+enum class DATASET_API NormMode {
+  kNone = 0,  ///< None type norm.
+  kOrtho = 1  ///< Ortho type norm.
+};
+
+/// \brief Possible options for norm in MelscaleFbanks.
+enum class DATASET_API NormType {
+  kNone = 0,    ///< None type norm.
+  kSlaney = 1,  ///< Slaney type norm.
+};
+
+/// \brief The mode for manual offload.
+enum class DATASET_API ManualOffloadMode {
+  kUnspecified,  ///< Not set, will use auto_offload setting instead.
+  kDisabled,     ///< Do not perform offload.
+  kEnabled       ///< Attempt to offload.
+};
+
+/// \brief Target devices to perform map operation.
+enum class DATASET_API MapTargetDevice {
+  kCpu = 0,     ///< CPU Device.
+  kGpu,         ///< Gpu Device.
+  kAscend310,   ///< Ascend310 Device.
+  kAscend910B,  ///< Ascend910B Device.
+  kInvalid = 100
+};
+
+/// \brief Possible options for mel_type in MelscaleFbanks.
+enum class DATASET_API MelType {
+  kHtk = 0,     ///< Htk scale type.
+  kSlaney = 1,  ///< Slaney scale type.
+};
+
+/// \brief The initial type of tensor implementation.
+enum class DATASET_API TensorImpl {
+  kNone,      ///< None type tensor.
+  kFlexible,  ///< Flexible type tensor, can be converted to any type.
+  kCv,        ///< CV type tensor.
+  kNP         ///< Numpy type tensor.
+};
+
+/// \brief The mode for shuffling data.
+enum class DATASET_API ShuffleMode {
+  kFalse = 0,   ///< No shuffling is performed.
+  kFiles = 1,   ///< Shuffle files only.
+  kGlobal = 2,  ///< Shuffle both the files and samples.
+  kInfile = 3   ///< Shuffle data within each file.
+};
+
+/// \brief Possible scale for input audio.
+enum class DATASET_API ScaleType {
+  kMagnitude = 0,  ///< Audio scale is magnitude.
+  kPower = 1,      ///< Audio scale is power.
+};
+
+/// \brief The scale for gain type.
+enum class DATASET_API GainType {
+  kAmplitude = 0,  ///< Audio gain type is amplitude.
+  kPower = 1,      ///< Audio gain type is power.
+  kDb = 2,         ///< Audio gain type is db.
+};
+
+/// \brief The method of padding.
+enum class DATASET_API BorderType {
+  kConstant = 0,  ///< Fill the border with constant values.
+  kEdge = 1,      ///< Fill the border with the last value on the edge.
+  kReflect = 2,   ///< Reflect the values on the edge omitting the last value of edge.
+  kSymmetric = 3  ///< Reflect the values on the edge repeating the last value of edge.
+};
+
+/// \brief Possible fix rotation angle for Rotate Op.
+enum class DATASET_API FixRotationAngle {
+  k0Degree = 1,             ///< Rotate 0 degree.
+  k0DegreeAndMirror = 2,    ///< Rotate 0 degree and apply horizontal flip.
+  k180Degree = 3,           ///< Rotate 180 degree.
+  k180DegreeAndMirror = 4,  ///< Rotate 180 degree and apply horizontal flip.
+  k90DegreeAndMirror = 5,   ///< Rotate 90 degree and apply horizontal flip.
+  k90Degree = 6,            ///< Rotate 90 degree.
+  k270DegreeAndMirror = 7,  ///< Rotate 270 degree and apply horizontal flip.
+  k270Degree = 8,           ///< Rotate 270 degree.
+};
+
+/// \brief Possible types for windows function.
+enum class DATASET_API WindowType {
+  kBartlett = 0,  ///< Bartlett window function.
+  kBlackman = 1,  ///< Blackman window function.
+  kHamming = 2,   ///< Hamming window function.
+  kHann = 3,      ///< Hann window function.
+  kKaiser = 4     ///< Kaiser window function.
+};
+
+/// \brief Possible options for Image format types in a batch.
+enum class DATASET_API ImageBatchFormat {
+  kNHWC = 0,  ///< Indicate the input batch is of NHWC format.
+  kNCHW = 1   ///< Indicate the input batch is of NCHW format.
+};
+
+/// \brief Possible options for Image format types.
+enum class DATASET_API ImageFormat {
+  HWC = 0,  ///< Indicate the input batch is of NHWC format
+  CHW = 1,  ///< Indicate the input batch is of NHWC format
+  HW = 2    ///< Indicate the input batch is of NHWC format
+};
+
+/// \brief Possible options for interpolation method.
+enum class DATASET_API InterpolationMode {
+  kLinear = 0,            ///< Interpolation method is linear interpolation.
+  kNearestNeighbour = 1,  ///< Interpolation method is nearest-neighbor interpolation.
+  kCubic = 2,             ///< Interpolation method is bicubic interpolation.
+  kArea = 3,              ///< Interpolation method is pixel area interpolation.
+  kCubicPil = 4           ///< Interpolation method is bicubic interpolation like implemented in pillow.
+};
+
+/// \brief Possible formats for Vdec output image.
+enum class DATASET_API VdecOutputFormat {
+  kYuvSemiplanar420 = 1,  ///< Output image with PIXEL_FORMAT_YUV_SEMIPLANAR_420.
+  kYvuSemiplanar420 = 2,  ///< Output image with PIXEL_FORMAT_YVU_SEMIPLANAR_420.
+};
+
+/// \brief Possible formats for Vdec input video.
+enum class DATASET_API VdecStreamFormat {
+  kH265MainLevel = 0,  ///< Input video with H265_MAIN_LEVEL
+  kH264BaselineLevel,  ///< Input video with H264_BASELINE_LEVEL
+  kH264MainLevel,      ///< Input video with H264_MAIN_LEVEL
+  kH264HighLevel       ///< Input video with H264_HIGH_LEVEL
+};
+
+/// \brief Possible tokenize modes for JiebaTokenizer.
+enum class DATASET_API JiebaMode {
+  kMix = 0,  ///< Tokenize with MPSegment algorithm.
+  kMp = 1,   ///< Tokenize with Hiddel Markov Model Segment algorithm.
+  kHmm = 2   ///< Tokenize with a mix of MPSegment and HMMSegment algorithm.
+};
+
+/// \brief Possible options for SPieceTokenizerOutType.
+enum class DATASET_API SPieceTokenizerOutType {
+  kString = 0,  ///< Output of sentencepiece tokenizer is string type.
+  kInt = 1      ///< Output of sentencepiece tokenizer is int type.
+};
+
+/// \brief Possible options for SPieceTokenizerLoadType.
+enum class DATASET_API SPieceTokenizerLoadType {
+  kFile = 0,  ///< Load sentencepiece tokenizer from local sentencepiece vocab file.
+  kModel = 1  ///< Load sentencepiece tokenizer from sentencepiece vocab instance.
+};
+
+/// \brief Type options for SentencePiece Model.
+enum class DATASET_API SentencePieceModel {
+  kUnigram = 0,  ///< Based on Unigram model.
+  kBpe = 1,      ///< Based on Byte Pair Encoding (BPE) model.
+  kChar = 2,     ///< Based on Char model.
+  kWord = 3      ///< Based on Word model.
+};
+
+/// \brief Possible options to specify a specific normalize mode.
+enum class DATASET_API NormalizeForm {
+  kNone = 0,  ///< Keep the input string tensor unchanged.
+  kNfc,       ///< Normalize with Normalization Form C.
+  kNfkc,      ///< Normalize with Normalization Form KC.
+  kNfd,       ///< Normalize with Normalization Form D.
+  kNfkd,      ///< Normalize with Normalization Form KD.
+};
+
+/// \brief Possible options for Mask.
+enum class DATASET_API RelationalOp {
+  kEqual = 0,     ///< equal to `==`
+  kNotEqual,      ///< equal to `!=`
+  kLess,          ///< equal to `<`
+  kLessEqual,     ///< equal to `<=`
+  kGreater,       ///< equal to `>`
+  kGreaterEqual,  ///< equal to `>=`
+};
+
+/// \brief Possible modes for slice patches.
+enum class DATASET_API SliceMode {
+  kPad = 0,   ///< Pad some pixels before slice to patches.
+  kDrop = 1,  ///< Drop remainder pixels before slice to patches.
+};
+
+/// \brief Possible options for SamplingStrategy.
+enum class DATASET_API SamplingStrategy {
+  kRandom = 0,     ///< Random sampling with replacement.
+  kEdgeWeight = 1  ///< Sampling with edge weight as probability.
+};
+
+/// \brief Possible options for fade shape.
+enum class DATASET_API FadeShape {
+  kLinear = 0,       ///< Fade shape is linear mode.
+  kExponential = 1,  ///< Fade shape is exponential mode.
+  kLogarithmic = 2,  ///< Fade shape is logarithmic mode.
+  kQuarterSine = 3,  ///< Fade shape is quarter_sine mode.
+  kHalfSine = 4,     ///< Fade shape is half_sine mode.
+};
+
+/// \brief Sample method for audio resample.
+enum class DATASET_API ResampleMethod {
+  kSincInterpolation = 0,  ///< Resample audio by sinc interpolation method
+  kKaiserWindow = 1,       ///< Resample audio by Kaiser window
+};
+
+/// \brief Possible configuration methods for processing error samples.
+enum class DATASET_API ErrorSamplesMode {
+  kReturn = 0,   ///< Erroneous sample results in error raised and returned
+  kReplace = 1,  ///< Erroneous sample is replaced with an internally determined sample
+  kSkip = 2      ///< Erroneous sample is skipped
+};
+
+/// \brief Convenience function to check bitmask for a 32bit int
+/// \param[in] bits a 32bit int to be tested
+/// \param[in] bitMask a 32bit int representing bit mask
+/// \return bool Result for the check
+inline bool DATASET_API BitTest(uint32_t bits, uint32_t bitMask) { return (bits & bitMask) == bitMask; }
+
+/// \brief Convenience function to set bitmask for a 32bit int
+/// \param[in] bits a 32bit int to deal with
+/// \param[in] bitMask a 32bit int representing bit mask
+inline void DATASET_API BitSet(uint32_t *bits, uint32_t bitMask) {
+  if (bits == nullptr) {
+    return;
+  }
+  *bits |= bitMask;
+}
+
+/// \brief Convenience function to clear bitmask from a 32bit int
+/// \param[in] bits a 32bit int to deal with
+/// \param[in] bitMask a 32bit int representing bit mask
+inline void DATASET_API BitClear(uint32_t *bits, uint32_t bitMask) {
+  if (bits == nullptr) {
+    return;
+  }
+  *bits &= (~bitMask);
+}
+
+constexpr uint32_t kFrameWidthMax = 4096;
+constexpr uint32_t kFrameHeightMax = 4096;
+constexpr uint32_t kFrameWidthMin = 128;
+constexpr uint32_t kFrameHeightMin = 128;
+
+constexpr int64_t kDeMaxDim = std::numeric_limits<int64_t>::max();
+constexpr int32_t kDeMaxRank = std::numeric_limits<int32_t>::max();
+constexpr int64_t kDeMaxFreq = std::numeric_limits<int64_t>::max();  // 9223372036854775807 or 2^(64-1)
+constexpr int64_t kDeMaxTopk = std::numeric_limits<int64_t>::max();
+
+constexpr uint32_t kCfgRowsPerBuffer = 1;
+constexpr uint32_t kCfgParallelWorkers = 8;
+constexpr uint32_t kCfgWorkerConnectorSize = 16;
+constexpr uint32_t kCfgOpConnectorSize = 16;
+constexpr uint32_t kCfgSendingBatch = 0;
+constexpr int32_t kCfgDefaultRankId = -1;
+constexpr uint32_t kCfgDefaultSeed = std::mt19937::default_seed;
+constexpr uint32_t kCfgMonitorSamplingInterval = 1000;        // timeout value for monitor sampling interval in
+                                                              // milliseconds
+constexpr uint32_t kCfgCallbackTimeout = 60;                  // timeout value for callback in seconds
+constexpr uint32_t kCfgMultiprocessingTimeoutInterval = 300;  // timeout value for multiprocessing interval in seconds
+constexpr int32_t kCfgDefaultCachePort = 50052;
+constexpr char kCfgDefaultCacheHost[] = "127.0.0.1";
+constexpr int32_t kDftCachePrefetchSize = 20;
+constexpr int32_t kDftNumConnections = 12;
+constexpr bool kDftAutoNumWorkers = false;
+constexpr char kDftMetaColumnPrefix[] = "_meta-";
+constexpr int32_t kDecimal = 10;  // used in strtol() to convert a string value according to decimal numeral system
+constexpr int32_t kMinLegalPort = 1025;
+constexpr int32_t kMaxLegalPort = 65535;
+
+// Invalid OpenCV type should not be from 0 to 7 (opencv4/opencv2/core/hal/interface.h)
+constexpr uint8_t kCVInvalidType = 255;
+
+using connection_id_type = uint64_t;
+using session_id_type = uint32_t;
+using row_id_type = int64_t;
+
+constexpr uint32_t kCfgAutoTuneInterval = 0;  // default number of steps
+}  // namespace dataset
+}  // namespace mindspore
+#endif  // MINDSPORE_CCSRC_MINDDATA_DATASET_INCLUDE_DATASET_CONSTANTS_H_