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

mindspore/include/api/delegate.h

@@ -20,6 +20,8 @@
 #include <map>
 #include <vector>
 #include <memory>
+#include <string>
+#include <utility>
 #include "schema/model_generated.h"
 #include "include/api/kernel.h"
 #include "include/api/delegate_api.h"
@@ -48,7 +50,7 @@ class MS_API DelegateModel {
 
   /// \brief Get Primitive of kernel::Kernel.
   ///
-  /// \param[in] a kernel in DelegateModel kernels vector.
+  /// \param[in] kernel kernel in DelegateModel kernels vector.
   ///
   /// \return The Primitive of The kernel.
   const T *GetPrimitive(kernel::Kernel *kernel) const {
@@ -85,6 +87,11 @@ class MS_API DelegateModel {
     return BeginKernelIterator() + insert_index + 1;
   }
 
+  /// \brief Get the nodes of DelegateModel.
+  ///
+  /// \return The pointer to nodes vector of DelegateModel.
+  std::vector<kernel::Kernel *> *nodes() { return kernels_; }
+
   /// \brief Get the input tensors of DelegateModel.
   ///
   /// \return The input tensor vector of DelegateModel.

mindspore/include/api/dual_abi_helper.h

@@ -67,18 +67,20 @@ inline std::set<std::string> SetCharToString(const std::set<std::vector<char>> &
   return ret;
 }
 
-inline std::map<std::vector<char>, int32_t> MapStringToChar(const std::map<std::string, int32_t> &s) {
-  std::map<std::vector<char>, int32_t> ret;
+template <class T>
+inline std::map<std::vector<char>, T> MapStringToChar(const std::map<std::string, T> &s) {
+  std::map<std::vector<char>, T> ret;
   std::transform(s.begin(), s.end(), std::inserter(ret, ret.begin()), [](auto str) {
-    return std::pair<std::vector<char>, int32_t>(std::vector<char>(str.first.begin(), str.first.end()), str.second);
+    return std::pair<std::vector<char>, T>(std::vector<char>(str.first.begin(), str.first.end()), str.second);
   });
   return ret;
 }
 
-inline std::map<std::string, int32_t> MapCharToString(const std::map<std::vector<char>, int32_t> &c) {
-  std::map<std::string, int32_t> ret;
+template <class T>
+inline std::map<std::string, T> MapCharToString(const std::map<std::vector<char>, T> &c) {
+  std::map<std::string, T> ret;
   std::transform(c.begin(), c.end(), std::inserter(ret, ret.begin()), [](auto ch) {
-    return std::pair<std::string, int32_t>(std::string(ch.first.begin(), ch.first.end()), ch.second);
+    return std::pair<std::string, T>(std::string(ch.first.begin(), ch.first.end()), ch.second);
   });
   return ret;
 }
@@ -151,24 +153,6 @@ inline std::vector<std::pair<std::vector<char>, int64_t>> PairStringInt64ToPairC
   return ret;
 }
 
-template <class T>
-inline std::map<std::vector<char>, T> PadInfoStringToChar(const std::map<std::string, T> &s_pad_info) {
-  std::map<std::vector<char>, T> ret;
-  std::transform(s_pad_info.begin(), s_pad_info.end(), std::inserter(ret, ret.begin()), [](auto str) {
-    return std::pair<std::vector<char>, T>(std::vector<char>(str.first.begin(), str.first.end()), str.second);
-  });
-  return ret;
-}
-
-template <class T>
-inline std::map<std::string, T> PadInfoCharToString(const std::map<std::vector<char>, T> &c_pad_info) {
-  std::map<std::string, T> ret;
-  std::transform(c_pad_info.begin(), c_pad_info.end(), std::inserter(ret, ret.begin()), [](auto ch) {
-    return std::pair<std::string, T>(std::string(ch.first.begin(), ch.first.end()), ch.second);
-  });
-  return ret;
-}
-
 template <class T>
 inline void TensorMapCharToString(const std::map<std::vector<char>, T> *c, std::unordered_map<std::string, T> *s) {
   if (c == nullptr || s == nullptr) {

mindspore/include/api/metrics/accuracy.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2021 Huawei Technologies Co., Ltd
+ * Copyright 2021-2023 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.
@@ -23,7 +23,7 @@ namespace mindspore {
 constexpr int METRICS_CLASSIFICATION = 0;
 constexpr int METRICS_MULTILABEL = 1;
 
-class AccuracyMetrics : public Metrics {
+class MS_API AccuracyMetrics : public Metrics {
  public:
   explicit AccuracyMetrics(int accuracy_metrics = METRICS_CLASSIFICATION, const std::vector<int> &input_indexes = {1},
                            const std::vector<int> &output_indexes = {0});

mindspore/include/api/metrics/metrics.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2021 Huawei Technologies Co., Ltd
+ * Copyright 2021-2023 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.
@@ -24,16 +24,17 @@ class MetricsImpl;
 class ModelImpl;
 class MSTensor;
 
-class Metrics {
+class MS_API Metrics {
  public:
   virtual ~Metrics() = default;
   virtual void Clear() {}
   virtual float Eval() { return 0.0; }
   virtual void Update(std::vector<MSTensor *> inputs, std::vector<MSTensor *> outputs) {}
+
  protected:
   friend class Model;
   friend class ModelImpl;
-  MetricsImpl* metrics_impl_;
+  MetricsImpl *metrics_impl_;
 };
 
 }  // namespace mindspore

mindspore/include/api/model.h

@@ -151,7 +151,7 @@ class MS_API Model {
   /// \return Status.
   Status UpdateWeights(const std::vector<MSTensor> &new_weights);
 
-  /// \brief Inference model.
+  /// \brief Inference model API. If use this API in train mode, it's equal to RunStep API.
   ///
   /// \param[in] inputs A vector where model inputs are arranged in sequence.
   /// \param[out] outputs Which is a pointer to a vector. The model outputs are filled in the container in sequence.
@@ -162,7 +162,7 @@ class MS_API Model {
   Status Predict(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs,
                  const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr);
 
-  /// \brief Inference model.
+  /// \brief Inference model API. If use this API in train mode, it's equal to RunStep API.
   ///
   /// \param[in] before CallBack before predict.
   /// \param[in] after CallBack after predict.
@@ -170,7 +170,7 @@ class MS_API Model {
   /// \return Status.
   Status Predict(const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr);
 
-  /// \brief Run model by step.
+  /// \brief Training API. Run model by step.
   ///
   /// \param[in] before CallBack before RunStep.
   /// \param[in] after CallBack after RunStep.
@@ -240,9 +240,14 @@ class MS_API Model {
 
   /// \brief Obtain all weights tensors of the model.
   ///
-  /// \return The vector that includes all gradient tensors.
+  /// \return The vector that includes all weights tensors.
   std::vector<MSTensor> GetFeatureMaps() const;
 
+  /// \brief Obtain all trainable parameters of the model optimizers.
+  ///
+  /// \return The vector that includes all trainable parameters.
+  std::vector<MSTensor> GetTrainableParams() const;
+
   /// \brief Update weights tensors of the model.
   ///
   /// \param[in] new_weights A vector new weights.

mindspore/include/api/model_group.h

@@ -0,0 +1,68 @@
+/**
+ * Copyright 2022 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_API_MODEL_GROUP_H
+#define MINDSPORE_INCLUDE_API_MODEL_GROUP_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include <utility>
+#include "include/api/model.h"
+#include "include/api/status.h"
+#include "include/api/types.h"
+#include "include/api/context.h"
+
+namespace mindspore {
+class ModelGroupImpl;
+
+/// \brief The ModelGroup class is used to define a MindSpore model group, facilitating
+/// multiple models to share workspace memory.
+class MS_API ModelGroup {
+ public:
+  ModelGroup();
+  ~ModelGroup() = default;
+  ModelGroup(const ModelGroup &) = delete;
+  ModelGroup &operator=(const ModelGroup &) = delete;
+
+  /// \brief Add models that require shared workspace memory.
+  ///
+  /// \param[in] model_path_list Define the list of model path.
+  ///
+  /// \return Status.
+  Status AddModel(const std::vector<std::string> &model_path_list);
+
+  /// \brief Add models that require shared workspace memory.
+  ///
+  /// \param[in] model_buff_list Define the list of model buff.
+  ///
+  /// \return Status.
+  Status AddModel(const std::vector<std::pair<const void *, size_t>> &model_buff_list);
+
+  /// \brief Calculate the max workspace of the added models.
+  ///
+  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR_Lite, ModelType::kMindIR. Only
+  /// ModelType::kMindIR_Lite is valid for Lite.
+  /// \param[in] ms_context A context used to store options.
+  ///
+  /// \return Status.
+  Status CalMaxSizeOfWorkspace(ModelType model_type, const std::shared_ptr<Context> &ms_context);
+
+ private:
+  std::shared_ptr<ModelGroupImpl> impl_;
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_MODEL_GROUP_H

mindspore/include/api/model_parallel_runner.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2022 Huawei Technologies Co., Ltd
+ * Copyright 2022-2023 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.
@@ -25,22 +25,32 @@
 namespace mindspore {
 /// \brief The RunnerConfig class  is used to store environment variables during execution
 /// management.
-class RunnerConfig {
+class MS_API RunnerConfig {
  public:
   struct Data;
   RunnerConfig();
-  ~RunnerConfig() = default;
+  ~RunnerConfig();
 
   /// \brief Set the number of workers at runtime. Only valid for ModelParallelRunner.
   ///
   /// \param[in] workers_num the number of workers at runtime.
   void SetWorkersNum(int32_t workers_num);
 
+  /// \brief Get the current operators parallel workers number setting. Only valid for ModelParallelRunner.
+  ///
+  /// \return The current operators parallel workers number setting.
+  int32_t GetWorkersNum() const;
+
   /// \brief Set the context at runtime. Only valid for ModelParallelRunner.
   ///
   /// \param[in] context store environment variables at runtime.
   void SetContext(const std::shared_ptr<Context> &context);
 
+  /// \brief Get the current context setting. Only valid for ModelParallelRunner.
+  ///
+  /// \return The current operators context setting.
+  std::shared_ptr<Context> GetContext() const;
+
   /// \brief Set the config before runtime. Only valid for ModelParallelRunner.
   ///
   /// \param[in] section The category of the configuration parameter.
@@ -52,16 +62,6 @@ class RunnerConfig {
   /// \return The current config setting.
   inline std::map<std::string, std::map<std::string, std::string>> GetConfigInfo() const;
 
-  /// \brief Get the current operators parallel workers number setting. Only valid for ModelParallelRunner.
-  ///
-  /// \return The current operators parallel workers number setting.
-  int32_t GetWorkersNum() const;
-
-  /// \brief Get the current context setting. Only valid for ModelParallelRunner.
-  ///
-  /// \return The current operators context setting.
-  std::shared_ptr<Context> GetContext() const;
-
   /// \brief Set the config path before runtime. Only valid for ModelParallelRunner.
   ///
   /// \param[in] config_path The path of the configuration parameter.
@@ -92,14 +92,14 @@ void RunnerConfig::SetConfigPath(const std::string &config_path) { SetConfigPath
 
 std::string RunnerConfig::GetConfigPath() const { return CharToString(GetConfigPathChar()); }
 
-class ModelPool;
+class ModelParallelRunnerImpl;
 
 /// \brief The ModelParallelRunner class is used to define a MindSpore ModelParallelRunner, facilitating Model
 /// management.
 class MS_API ModelParallelRunner {
  public:
-  ModelParallelRunner() = default;
-  ~ModelParallelRunner() = default;
+  ModelParallelRunner();
+  ~ModelParallelRunner();
 
   /// \brief build a model parallel runner from model path so that it can run on a device.
   ///
@@ -142,7 +142,7 @@ class MS_API ModelParallelRunner {
 
  private:
   Status Init(const std::vector<char> &model_path, const std::shared_ptr<RunnerConfig> &runner_config);
-  std::shared_ptr<ModelPool> model_pool_ = nullptr;
+  std::shared_ptr<ModelParallelRunnerImpl> model_parallel_runner_impl_ = nullptr;
 };
 
 Status ModelParallelRunner::Init(const std::string &model_path, const std::shared_ptr<RunnerConfig> &runner_config) {

mindspore/include/api/net.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2022 Huawei Technologies Co., Ltd
+ * Copyright 2022-2023 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.
@@ -36,14 +36,14 @@ class NodeSet;
 class Graph;
 class NetData;
 
-class NetBase {
+class MS_API NetBase {
  public:
   NetBase() = default;
   virtual std::vector<Expr *> operator()(const std::vector<Expr *> &inputs) = 0;
   virtual uint32_t type() = 0;
 };
 
-class Node : public NetBase {
+class MS_API Node : public NetBase {
  public:
   Node();
   virtual ~Node();
@@ -65,7 +65,7 @@ class Node : public NetBase {
   std::shared_ptr<NodeImpl> impl_ = nullptr;
 };
 
-class Net : public NetBase, public std::enable_shared_from_this<Net> {
+class MS_API Net : public NetBase, public std::enable_shared_from_this<Net> {
  public:
   Net();
   virtual ~Net();
@@ -116,12 +116,12 @@ class Net : public NetBase, public std::enable_shared_from_this<Net> {
   std::shared_ptr<NetImpl> impl_;
 };
 
-class SoftMaxCrossEntropyCfg {
+class MS_API SoftMaxCrossEntropyCfg {
  public:
   std::string reduction = "mean"; /**<  Specifies reduction mode. The optional values are "none", "mean", "sum" */
 };
 
-class AdamConfig {
+class MS_API AdamConfig {
  public:
   float learning_rate_ = 1e-3;
   float beta1_ = 0.9;
@@ -131,11 +131,12 @@ class AdamConfig {
 };
 
 namespace NN {
-Net *NetWithLoss(Net *net, Node *loss);
-Graph *GraphWithLoss(Graph *g, Node *loss);
-Node *Adam(std::shared_ptr<NodeSet> learn, const AdamConfig &cfg);
-Node *SoftmaxCrossEntropy(const SoftMaxCrossEntropyCfg &cfg);
-std::unique_ptr<Node> Input(std::vector<int> dims, DataType data_type = DataType::kNumberTypeFloat32, int fmt = NHWC);
+MS_API Net *NetWithLoss(Net *net, Node *loss);
+MS_API Graph *GraphWithLoss(Graph *g, Node *loss);
+MS_API Node *Adam(std::shared_ptr<NodeSet> learn, const AdamConfig &cfg);
+MS_API Node *SoftmaxCrossEntropy(const SoftMaxCrossEntropyCfg &cfg);
+MS_API std::unique_ptr<Node> Input(std::vector<int> dims, DataType data_type = DataType::kNumberTypeFloat32,
+                                   int fmt = NHWC);
 };  // namespace NN
 }  // namespace mindspore
 #endif  // MINDSPORE_INCLUDE_API_NET_H

mindspore/include/api/serialization.h

@@ -79,16 +79,22 @@ class MS_API Serialization {
   ///
   /// \param[in] model The model data.
   /// \param[in] model_type The model file type.
-  /// \param[out] model_data The model parameter data.
+  /// \param[out] model_data The model buffer.
+  /// \param[in] quantization_type The quantification type.
+  /// \param[in] export_inference_only Whether to export a reasoning only model.
+  /// \param[in] output_tensor_name The set the name of the output tensor of the exported reasoning model, default as
+  /// empty, and export the complete reasoning model.
   ///
   /// \return Status.
-  static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data);
+  inline static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data,
+                                   QuantizationType quantization_type = kNoQuant, bool export_inference_only = true,
+                                   const std::vector<std::string> &output_tensor_name = {});
 
   /// \brief Export training model from file.
   ///
   /// \param[in] model The model data.
   /// \param[in] model_type The model file type.
-  /// \param[in] model_file The exported model file.
+  /// \param[in] model_file The path of exported model file.
   /// \param[in] quantization_type The quantification type.
   /// \param[in] export_inference_only Whether to export a reasoning only model.
   /// \param[in] output_tensor_name The set the name of the output tensor of the exported reasoning model, default as
@@ -111,6 +117,9 @@ class MS_API Serialization {
   static Status ExportModel(const Model &model, ModelType model_type, const std::vector<char> &model_file,
                             QuantizationType quantization_type, bool export_inference_only,
                             const std::vector<std::vector<char>> &output_tensor_name);
+  static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data,
+                            QuantizationType quantization_type, bool export_inference_only,
+                            const std::vector<std::vector<char>> &output_tensor_name);
 };
 
 Status Serialization::Load(const void *model_data, size_t data_size, ModelType model_type, Graph *graph,
@@ -129,7 +138,7 @@ Status Serialization::Load(const std::vector<std::string> &files, ModelType mode
 }
 
 Status Serialization::SetParameters(const std::map<std::string, Buffer> &parameters, Model *model) {
-  return SetParameters(PadInfoStringToChar<Buffer>(parameters), model);
+  return SetParameters(MapStringToChar<Buffer>(parameters), model);
 }
 
 Status Serialization::ExportModel(const Model &model, ModelType model_type, const std::string &model_file,
@@ -139,5 +148,12 @@ Status Serialization::ExportModel(const Model &model, ModelType model_type, cons
                      VectorStringToChar(output_tensor_name));
 }
 
+Status Serialization::ExportModel(const Model &model, ModelType model_type, Buffer *model_data,
+                                  QuantizationType quantization_type, bool export_inference_only,
+                                  const std::vector<std::string> &output_tensor_name) {
+  return ExportModel(model, model_type, model_data, quantization_type, export_inference_only,
+                     VectorStringToChar(output_tensor_name));
+}
+
 }  // namespace mindspore
 #endif  // MINDSPORE_INCLUDE_API_SERIALIZATION_H

mindspore/include/api/status.h

@@ -68,7 +68,7 @@ enum StatusCode : uint32_t {
   kMCInvalidInput = kMC | 0x3,
   kMCInvalidArgs = kMC | 0x4,
 
-  // Lite  // Common error code, range: [-1, -100）
+  // Lite  // Common error code, range: [-1, -100)
   kLiteError = kLite | (0x0FFFFFFF & -1),            /**< Common error code. */
   kLiteNullptr = kLite | (0x0FFFFFFF & -2),          /**< NULL pointer returned.*/
   kLiteParamInvalid = kLite | (0x0FFFFFFF & -3),     /**< Invalid parameter.*/
@@ -118,8 +118,10 @@ class MS_API Status {
   inline std::string ToString() const;
 
   int GetLineOfCode() const;
+  inline std::string GetFileName() const;
   inline std::string GetErrDescription() const;
   inline std::string SetErrDescription(const std::string &err_description);
+  inline void SetStatusMsg(const std::string &status_msg);
 
   MS_API friend std::ostream &operator<<(std::ostream &os, const Status &s);
 
@@ -144,8 +146,10 @@ class MS_API Status {
   Status(enum StatusCode status_code, const std::vector<char> &status_msg);
   Status(enum StatusCode code, int line_of_code, const char *file_name, const std::vector<char> &extra);
   std::vector<char> ToCString() const;
+  std::vector<char> GetFileNameChar() const;
   std::vector<char> GetErrDescriptionChar() const;
   std::vector<char> SetErrDescription(const std::vector<char> &err_description);
+  void SetStatusMsgChar(const std::vector<char> &status_msg);
   static std::vector<char> CodeAsCString(enum StatusCode c);
 
   struct Data;
@@ -157,10 +161,12 @@ Status::Status(enum StatusCode status_code, const std::string &status_msg)
 Status::Status(const enum StatusCode code, int line_of_code, const char *file_name, const std::string &extra)
     : Status(code, line_of_code, file_name, StringToChar(extra)) {}
 std::string Status::ToString() const { return CharToString(ToCString()); }
+std::string Status::GetFileName() const { return CharToString(GetFileNameChar()); }
 std::string Status::GetErrDescription() const { return CharToString(GetErrDescriptionChar()); }
 std::string Status::SetErrDescription(const std::string &err_description) {
   return CharToString(SetErrDescription(StringToChar(err_description)));
 }
+void Status::SetStatusMsg(const std::string &status_msg) { SetStatusMsgChar(StringToChar(status_msg)); }
 std::string Status::CodeAsString(enum StatusCode c) { return CharToString(CodeAsCString(c)); }
 }  // namespace mindspore
 #endif  // MINDSPORE_INCLUDE_API_STATUS_H

mindspore/include/api/types.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020-2022 Huawei Technologies Co., Ltd
+ * Copyright 2020-2023 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.
@@ -28,31 +28,35 @@
 
 namespace mindspore {
 enum ModelType : uint32_t {
-  kMindIR = 0,
-  kAIR = 1,
-  kOM = 2,
-  kONNX = 3,
-  kMindIR_Lite = 4,
-  // insert new data type here
-  kUnknownType = 0xFFFFFFFF
+  kMindIR = 0,               ///< Model type is MindIR
+  kAIR = 1,                  ///< Model type is AIR
+  kOM = 2,                   ///< Model type is OM
+  kONNX = 3,                 ///< Model type is ONNX
+  kMindIR_Lite = 4,          ///< Model type is MindIR_LITE
+  kUnknownType = 0xFFFFFFFF  ///< Unknown model type
 };
 
-enum QuantizationType : uint32_t { kNoQuant = 0, kWeightQuant = 1, kFullQuant = 2, kUnknownQuantType = 0xFFFFFFFF };
+enum QuantizationType : uint32_t {
+  kNoQuant = 0,                   ///< Do not quantize
+  kWeightQuant = 1,               ///< Only Quantize weight
+  kFullQuant = 2,                 ///< Quantize whole network
+  kUnknownQuantType = 0xFFFFFFFF  ///< Quantization type unknown
+};
 
 enum OptimizationLevel : uint32_t {
-  kO0 = 0,    // Do not change
-  kO2 = 2,    // Cast network to float16, keep batchnorm and loss in float32,
-  kO3 = 3,    // Cast network to float16, including bacthnorm
-  kAuto = 4,  // Choose optimization based on device
-  kOptimizationType = 0xFFFFFFFF
+  kO0 = 0,                        ///< Do not optimize
+  kO2 = 2,                        ///< Cast network to float16, keep batchnorm and loss in float32,
+  kO3 = 3,                        ///< Cast network to float16, including bacthnorm
+  kAuto = 4,                      ///< Choose optimization based on device
+  kOptimizationType = 0xFFFFFFFF  ///< Unknown optimization type
 };
 
 struct QuantParam {
-  int bit_num;
-  double scale;
-  int32_t zero_point;
-  double min;
-  double max;
+  int bit_num;         ///< Quantization bit num
+  double scale;        ///< Quantization scale
+  int32_t zero_point;  ///< Quantization zero point
+  double min;          ///< Quantization min value
+  double max;          ///< Quantization max value
 };
 
 class Allocator;
@@ -364,7 +368,7 @@ std::string MSTensor::Name() const { return CharToString(CharName()); }
 
 void MSTensor::SetTensorName(const std::string &name) { SetTensorName(StringToChar(name)); }
 
-using Key = struct Key {
+using Key = struct MS_API Key {
   const size_t max_key_len = 32;
   size_t len = 0;
   unsigned char key[32] = {0};
@@ -386,7 +390,7 @@ using MSKernelCallBack =
   std::function<bool(const std::vector<MSTensor> & /* inputs */, const std::vector<MSTensor> & /* outputs */,
                      const MSCallBackParam &opInfo)>;
 
-std::vector<char> CharVersion();
+MS_API std::vector<char> CharVersion();
 inline std::string Version() { return CharToString(CharVersion()); }
 
 }  // namespace mindspore

mindspore/include/api/visible.h

@@ -18,8 +18,12 @@
 
 #ifndef MS_API
 #ifdef _WIN32
+#ifdef BUILDING_DLL
 #define MS_API __declspec(dllexport)
 #else
+#define MS_API __declspec(dllimport)
+#endif
+#else
 #define MS_API __attribute__((visibility("default")))
 #endif  // _WIN32
 #endif

mindspore/include/c_api/model_c.h

@@ -62,6 +62,11 @@ MS_API void MSModelDestroy(MSModelHandle *model);
 /// \param[in] workspace_size Define the workspace size.
 MS_API void MSModelSetWorkspace(MSModelHandle model, void *workspace, size_t workspace_size);
 
+/// \brief Calculate the workspace size required for model inference. Only valid for Iot.
+///
+/// \param[in] model Model object handle.
+MS_API size_t MSModelCalcWorkspaceSize(MSModelHandle model);
+
 /// \brief Build the model from model file buffer so that it can run on a device.
 ///
 /// \param[in] model Model object handle.

mindspore/include/c_api/status_c.h

@@ -35,7 +35,7 @@ typedef enum MSStatus {
   // Core
   kMSStatusCoreFailed = kMSCompCodeCore | 0x1,
 
-  // Lite  // Common error code, range: [-1, -100）
+  // Lite  // Common error code, range: [-1, -100)
   kMSStatusLiteError = kMSCompCodeLite | (0x0FFFFFFF & -1),            /**< Common error code. */
   kMSStatusLiteNullptr = kMSCompCodeLite | (0x0FFFFFFF & -2),          /**< NULL pointer returned.*/
   kMSStatusLiteParamInvalid = kMSCompCodeLite | (0x0FFFFFFF & -3),     /**< Invalid parameter.*/

mindspore/include/dataset/config.h

@@ -75,7 +75,7 @@ int32_t DATASET_API get_prefetch_size();
 /// \par Example
 /// \code
 ///     // Set a new global configuration value for the number of parallel workers.
-///     // Now parallel dataset operators will run with 16 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);

mindspore/include/dataset/constants.h

@@ -71,6 +71,13 @@ enum class DATASET_API ConvertMode {
   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.
@@ -284,6 +291,13 @@ enum class DATASET_API ResampleMethod {
   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