mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.0rc1__cp310-cp310-win_amd64.whl

mindspore/device_context/ascend/op_tuning.py

@@ -21,7 +21,7 @@ except ImportError:
 from .device import _is_supported
 
 function_status = {'op_compile': False, 'aoe_tune_mode': False,
-                   'aoe_job_type': False, 'aclnn_cache': False}
+                   'aoe_job_type': False}
 
 
 def op_compile(value):
@@ -121,37 +121,3 @@ def aoe_job_type(config):
             f"For 'aoe_job_type', the config must be one of {aoe_cfgs}, but got {config}."
         )
     AscendOpTuningConf.get_instance().set_aoe_job_type(config)
-
-
-def aclnn_cache(enable_global_cache=False, cache_queue_length=10000):
-    """
-    Configure aclnn cache parameters.
-
-    Args:
-        enable_global_cache (bool): Set the calnn cache to global when GRAPH_MODE.
-            Default: ``False``.
-        cache_queue_length (int, optional): Set the cache queue length.
-            Default: ``10000``.
-
-    Examples:
-        >>> import mindspore as ms
-        >>> ms.device_context.ascend.op_tuning.aclnn_cache(True, 10000)
-    """
-    if not function_status['aclnn_cache']:
-        function_status['aclnn_cache'] = True
-        if not _is_supported():
-            return
-    # Check the configuration environment whether valid
-    if AscendOpTuningConf.get_instance().is_aclnn_cache_configured():
-        raise RuntimeError("The 'aclnn_cache' can not be set repeatedly.")
-    cache_cfgs = [True, False]
-    if enable_global_cache not in cache_cfgs:
-        raise ValueError(
-            f"For 'aclnn_cache', the config must be one of {cache_cfgs}, but got {enable_global_cache}."
-        )
-    AscendOpTuningConf.get_instance().set_aclnn_global_cache(enable_global_cache)
-    if cache_queue_length < 0:
-        raise ValueError(
-            f"For 'aclnn_cache', the config must greater than 0, but got {enable_global_cache}."
-        )
-    AscendOpTuningConf.get_instance().set_cache_queue_length(cache_queue_length)

mindspore/experimental/llm_boost/ascend_native/llama_boost_ascend_native.py

@@ -18,7 +18,6 @@ import os
 import numpy as np
 from mindspore.common import Tensor, dtype
 from mindspore.experimental.llm_boost.ascend_native.llm_boost import LLMBoost
-from mindspore.experimental.llm_boost.register import LlmBoostRegister, LlmBoostType
 
 def RoundUp(val: int, align: int) -> int:
     if align == 0:
@@ -43,8 +42,6 @@ def ConvertTensor(nd_mat: np.ndarray, transpose: bool = True, nd2nz: bool = True
     nz_mat = nz_mat.reshape(r, c)
     return nz_mat
 
-
-@LlmBoostRegister.register(LlmBoostType.ASCEND_NATIVE, "Llama")
 class LlamaBoostAscendNative(LLMBoost):
     r"""
     Implements an Llama model in a single kernel.

mindspore/include/api/cell.h

@@ -31,9 +31,7 @@ using Output = InputAndOutput;
 
 class MS_API CellBase {
  public:
-  /// \brief Constructor of Cellbase.
   CellBase() = default;
-  /// \brief Destructor of Cellbase.
   virtual ~CellBase() = default;
   /// \brief Construct using inputs.
   ///
@@ -65,21 +63,12 @@ class MS_API Cell : public CellBase {
 class MS_API GraphCell final : public Cell<GraphCell> {
  public:
   class GraphImpl;
-  /// \brief Constructor of GraphCell.
+
   GraphCell() = default;
-  /// \brief Destructor of GraphCell.
   ~GraphCell() override = default;
-  /// \brief Constructor of GraphCell.
-  ///
-  /// \param[in] graph Graph to construct.
+
   explicit GraphCell(const Graph &graph);
-  /// \brief Constructor of GraphCell.
-  ///
-  /// \param[in] graph Graph to construct.
   explicit GraphCell(Graph &&graph);
-  /// \brief Constructor of GraphCell.
-  ///
-  /// \param[in] graph Graph to construct.
   explicit GraphCell(const std::shared_ptr<Graph> &graph);
   /// \brief Set a context.
   ///
@@ -120,25 +109,12 @@ class MS_API GraphCell final : public Cell<GraphCell> {
 
 class MS_API InputAndOutput {
  public:
-  /// \brief Constructor of InputAndOutput.
   InputAndOutput();
-  /// \brief Destructor of InputAndOutput.
   ~InputAndOutput() = default;
-  /// \brief Constructor of InputAndOutput.
-  ///
-  /// \param[in] cell The cellbase.
-  ///
-  /// \param[in] prev The previous inputs/outputs.
-  ///
-  /// \param[in] index Index of inputs/outputs.
+
   InputAndOutput(const std::shared_ptr<CellBase> &cell, const std::vector<InputAndOutput> &prev, int32_t index);
-  /// \brief Get index.
-  ///
-  /// \return index Index of inputs/outputs.
+
   int32_t GetIndex() const { return index_; }
-  /// \brief Set index.
-  ///
-  /// \param[in] index Index to be set.
   void SetIndex(int32_t index) { index_ = index; }
 
  private:

mindspore/include/api/cfg.h

@@ -28,50 +28,35 @@ namespace mindspore {
 constexpr int iter_th = 1000;
 class MS_API MixPrecisionCfg {
  public:
-  /// \brief Constructor of mix precision training config.
   MixPrecisionCfg() {
     this->dynamic_loss_scale_ = false;
     this->loss_scale_ = 128.0f;
     this->keep_batchnorm_fp32_ = true;
     this->num_of_not_nan_iter_th_ = iter_th;
   }
-  /// \brief Constructor of mix precision training config.
-  ///
-  /// \param[in] rhs The config of mix precision.
   MixPrecisionCfg(const MixPrecisionCfg &rhs) {
     this->dynamic_loss_scale_ = rhs.dynamic_loss_scale_;
     this->loss_scale_ = rhs.loss_scale_;
     this->keep_batchnorm_fp32_ = rhs.keep_batchnorm_fp32_;
     this->num_of_not_nan_iter_th_ = rhs.num_of_not_nan_iter_th_;
   }
-  /// \brief Destructor of mix precision config.
   ~MixPrecisionCfg() = default;
 
-  /// \brief Enable/disable dynamic loss scale during mix precision training.
-  bool dynamic_loss_scale_ = false;
-  /// \brief Initial loss scale factor.
-  float loss_scale_;
-  /// \brief Keep batch norm in FP32 while training.
-  bool keep_batchnorm_fp32_ = true;
-  /// \brief A threshold for modifying loss scale when dynamic loss scale is enabled.
-  uint32_t num_of_not_nan_iter_th_;
-  /// \brief Is mix precision model export from mindspore.
-  bool is_raw_mix_precision_ = false;
+  bool dynamic_loss_scale_ = false;   /**< Enable/disable dynamic loss scale during mix precision training */
+  float loss_scale_;                  /**< Initial loss scale factor  */
+  bool keep_batchnorm_fp32_ = true;   /**< Keep batch norm in FP32 while training */
+  uint32_t num_of_not_nan_iter_th_;   /**< a threshold for modifying loss scale when dynamic loss scale is enabled */
+  bool is_raw_mix_precision_ = false; /**< Is mix precision model export from mindspore  */
 };
 
 class MS_API TrainCfg {
  public:
-  /// \brief Constructor of training config.
   TrainCfg() = default;
-  /// \brief Constructor of training config.
-  ///
-  /// \param[in] rhs The training config.
   TrainCfg(const TrainCfg &rhs) {
     this->loss_name_ = rhs.loss_name_;
     this->mix_precision_cfg_ = rhs.mix_precision_cfg_;
     this->accumulate_gradients_ = rhs.accumulate_gradients_;
   }
-  /// \brief Destructor of training config.
   ~TrainCfg() = default;
 
   /// \brief obtain part of the name that identify a loss kernel.
@@ -82,11 +67,9 @@ class MS_API TrainCfg {
   ///
   /// \param[in] loss_name define part of the name that identify a loss kernel.
   inline void SetLossName(const std::vector<std::string> &loss_name);
-  /// \brief Optimization level.
+
   OptimizationLevel optimization_level_ = kO0;
-  /// \brief Mix precision configuration.
-  MixPrecisionCfg mix_precision_cfg_;
-  /// \brief If accumulate gradients is used.
+  MixPrecisionCfg mix_precision_cfg_; /**< Mix precision configuration */
   bool accumulate_gradients_ = false;
 
  private:

mindspore/include/api/context.h

@@ -50,7 +50,6 @@ class DeviceInfoContext;
 /// \brief Context is used to store environment variables during execution.
 class MS_API Context {
  public:
-  /// \brief Data of context.
   struct Data;
   Context();
   ~Context() = default;

mindspore/include/api/delegate.h

@@ -129,6 +129,7 @@ class Delegate : public IDelegate<LiteDelegateGraph, kernel::Kernel, kernel::Ker
   ///
   /// \return Status. If Status is kLiteNotSupport, the program will return to the MindSpore Lite inner inference.
   virtual Status Init() = 0;
+
   /// \brief Create kernel.
   ///
   /// \param[in] node The kernel to be created.
@@ -138,6 +139,7 @@ class Delegate : public IDelegate<LiteDelegateGraph, kernel::Kernel, kernel::Ker
     // return node as kernel since they are same one.
     return node;
   }
+
   /// \brief Check if the node is delegate node.
   ///
   /// \param[in] node The kernel to verify.

mindspore/include/api/dual_abi_helper.h

@@ -28,11 +28,6 @@
 
 namespace mindspore {
 using VecChar = std::vector<char>;
-/// \brief Transform string to char.
-///
-/// \param[in] s Define the string to transform.
-///
-/// \return Vector of chars.
 inline std::vector<char> StringToChar(const std::string &s) {
   if (s.empty()) {
     const auto empty = std::vector<char>();
@@ -40,11 +35,7 @@ inline std::vector<char> StringToChar(const std::string &s) {
   }
   return std::vector<char>(s.begin(), s.end());
 }
-/// \brief Transform char to string.
-///
-/// \param[in] c Define the chars to transform.
-///
-/// \return String.
+
 inline std::string CharToString(const std::vector<char> &c) {
   if (c.empty()) {
     const auto empty = "";
@@ -52,71 +43,43 @@ inline std::string CharToString(const std::vector<char> &c) {
   }
   return std::string(c.begin(), c.end());
 }
-/// \brief Transform pair of string to char.
-///
-/// \param[in] s Pair of strings to transform.
-///
-/// \return Pair of chars.
+
 inline std::pair<std::vector<char>, int32_t> PairStringToChar(const std::pair<std::string, int32_t> &s) {
   return std::pair<std::vector<char>, int32_t>(std::vector<char>(s.first.begin(), s.first.end()), s.second);
 }
-/// \brief Transform pair of char to string.
-///
-/// \param[in] c Pair of chars to transform.
-///
-/// \return Pair of strings.
+
 inline std::pair<std::string, int32_t> PairCharToString(const std::pair<std::vector<char>, int32_t> &c) {
   return std::pair<std::string, int32_t>(std::string(c.first.begin(), c.first.end()), c.second);
 }
-/// \brief Transform vector of string to chars.
-///
-/// \param[in] s Vector of strings.
-///
-/// \return Vector of vector of chars.
+
 inline std::vector<std::vector<char>> VectorStringToChar(const std::vector<std::string> &s) {
   std::vector<std::vector<char>> ret;
   std::transform(s.begin(), s.end(), std::back_inserter(ret),
                  [](auto str) { return std::vector<char>(str.begin(), str.end()); });
   return ret;
 }
-/// \brief Transform vector of chars to strings.
-///
-/// \param[in] c Vector of vector ofof schars.
-///
-/// \return Vector of strings.
+
 inline std::vector<std::string> VectorCharToString(const std::vector<std::vector<char>> &c) {
   std::vector<std::string> ret;
   std::transform(c.begin(), c.end(), std::back_inserter(ret),
                  [](auto ch) { return std::string(ch.begin(), ch.end()); });
   return ret;
 }
-/// \brief Transform set of strings to chars.
-///
-/// \param[in] s Set of strings.
-///
-/// \return Set of vector of chars.
+
 inline std::set<std::vector<char>> SetStringToChar(const std::set<std::string> &s) {
   std::set<std::vector<char>> ret;
   std::transform(s.begin(), s.end(), std::inserter(ret, ret.begin()),
                  [](auto str) { return std::vector<char>(str.begin(), str.end()); });
   return ret;
 }
-/// \brief Transform set of chars to strings.
-///
-/// \param[in] c Set of chars.
-///
-/// \return Set of strings.
+
 inline std::set<std::string> SetCharToString(const std::set<std::vector<char>> &c) {
   std::set<std::string> ret;
   std::transform(c.begin(), c.end(), std::inserter(ret, ret.begin()),
                  [](auto ch) { return std::string(ch.begin(), ch.end()); });
   return ret;
 }
-/// \brief Transform map of strings to chars.
-///
-/// \param[in] s Map of strings.
-///
-/// \return Map of vector of chars.
+
 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;
@@ -125,11 +88,7 @@ inline std::map<std::vector<char>, T> MapStringToChar(const std::map<std::string
   });
   return ret;
 }
-/// \brief Transform map of chars to strings.
-///
-/// \param[in] c Map of vector of chars.
-///
-/// \return Map of strings.
+
 template <class T>
 inline std::map<std::string, T> MapCharToString(const std::map<std::vector<char>, T> &c) {
   std::map<std::string, T> ret;
@@ -138,11 +97,7 @@ inline std::map<std::string, T> MapCharToString(const std::map<std::vector<char>
   });
   return ret;
 }
-/// \brief Transform unordered map of strings to chars.
-///
-/// \param[in] s Unordered_map of strings.
-///
-/// \return Map of vector of chars.
+
 inline std::map<std::vector<char>, std::vector<char>> UnorderedMapStringToChar(
   const std::unordered_map<std::string, std::string> &s) {
   std::map<std::vector<char>, std::vector<char>> ret;
@@ -152,11 +107,7 @@ inline std::map<std::vector<char>, std::vector<char>> UnorderedMapStringToChar(
   });
   return ret;
 }
-/// \brief Transform unordered map of chars to strings.
-///
-/// \param[in] c Map of vector of chars.
-///
-/// \return Unordered map of strings.
+
 inline std::unordered_map<std::string, std::string> UnorderedMapCharToString(
   const std::map<std::vector<char>, std::vector<char>> &c) {
   std::unordered_map<std::string, std::string> ret;
@@ -166,11 +117,7 @@ inline std::unordered_map<std::string, std::string> UnorderedMapCharToString(
   });
   return ret;
 }
-/// \brief Transform map of strings to vector of chars.
-///
-/// \param[in] s Map of vector of strings.
-///
-/// \return Map of vector of chars.
+
 inline std::map<std::vector<char>, std::vector<char>> MapStringToVectorChar(
   const std::map<std::string, std::string> &s) {
   std::map<std::vector<char>, std::vector<char>> ret;
@@ -180,11 +127,7 @@ inline std::map<std::vector<char>, std::vector<char>> MapStringToVectorChar(
   });
   return ret;
 }
-/// \brief Transform map of chars to strings.
-///
-/// \param[in] c Map of vector of chars.
-///
-/// \return Map of strings.
+
 inline std::map<std::string, std::string> MapVectorCharToString(
   const std::map<std::vector<char>, std::vector<char>> &c) {
   std::map<std::string, std::string> ret;
@@ -194,11 +137,7 @@ inline std::map<std::string, std::string> MapVectorCharToString(
   });
   return ret;
 }
-/// \brief Transform class index string to char.
-///
-/// \param[in] s Vector of pair of strings.
-///
-/// \return Vector of pair of vector of chars.
+
 inline std::vector<std::pair<std::vector<char>, std::vector<int32_t>>> ClassIndexStringToChar(
   const std::vector<std::pair<std::string, std::vector<int32_t>>> &s) {
   std::vector<std::pair<std::vector<char>, std::vector<int32_t>>> ret;
@@ -208,11 +147,7 @@ inline std::vector<std::pair<std::vector<char>, std::vector<int32_t>>> ClassInde
   });
   return ret;
 }
-/// \brief Transform class index char to string.
-///
-/// \param[in] c Vector of pair of schar.
-///
-/// \return Vector of pair of vector of strings.
+
 inline std::vector<std::pair<std::string, std::vector<int32_t>>> ClassIndexCharToString(
   const std::vector<std::pair<std::vector<char>, std::vector<int32_t>>> &c) {
   std::vector<std::pair<std::string, std::vector<int32_t>>> ret;
@@ -221,11 +156,7 @@ inline std::vector<std::pair<std::string, std::vector<int32_t>>> ClassIndexCharT
   });
   return ret;
 }
-/// \brief Transform pair string of int64 to pair char of int64.
-///
-/// \param[in] s Vector of pair of strings.
-///
-/// \return Vector of pair of vector of chars.
+
 inline std::vector<std::pair<std::vector<char>, int64_t>> PairStringInt64ToPairCharInt64(
   const std::vector<std::pair<std::string, int64_t>> &s) {
   std::vector<std::pair<std::vector<char>, int64_t>> ret;
@@ -234,11 +165,7 @@ inline std::vector<std::pair<std::vector<char>, int64_t>> PairStringInt64ToPairC
   });
   return ret;
 }
-/// \brief Transform tensor map of char to string.
-///
-/// \param[in] c Map of Vector of chars.
-///
-/// \param[in] s Unordered map of strings, which will be changed after the function.
+
 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) {
@@ -250,11 +177,7 @@ inline void TensorMapCharToString(const std::map<std::vector<char>, T> *c, std::
     s->insert(std::pair<std::string, T>(key, val));
   }
 }
-/// \brief Transform map of map of chars to map of strings.
-///
-/// \param[in] c Map of map of chars.
-///
-/// \return Map of strings.
+
 inline std::map<std::string, std::map<std::string, std::string>> MapMapCharToString(
   const std::map<std::vector<char>, std::map<std::vector<char>, std::vector<char>>> &c) {
   std::map<std::string, std::map<std::string, std::string>> ret;
@@ -268,11 +191,7 @@ inline std::map<std::string, std::map<std::string, std::string>> MapMapCharToStr
   }
   return ret;
 }
-/// \brief Transform map of map of strings to map of chars.
-///
-/// \param[in] s Map of map of strings.
-///
-/// \return Map of chars.
+
 inline std::map<std::vector<char>, std::map<std::vector<char>, std::vector<char>>> MapMapStringToChar(
   const std::map<std::string, std::map<std::string, std::string>> &s) {
   std::map<std::vector<char>, std::map<std::vector<char>, std::vector<char>>> ret;

mindspore/include/api/graph.h

@@ -27,27 +27,14 @@ namespace mindspore {
 class MS_API Graph {
  public:
   class GraphData;
-  /// \brief Constructor of graph.
   Graph();
-  /// \brief Constructor of graph.
-  ///
-  /// \param[in] graph_data define the graph_data of graph.
   explicit Graph(const std::shared_ptr<GraphData> &graph_data);
-  /// \brief Constructor of graph.
-  ///
-  /// \param[in] graph_data define the graph_data of graph.
   explicit Graph(std::shared_ptr<GraphData> &&graph_data);
-  /// \brief Constructor of Kernel.
   explicit Graph(std::nullptr_t);
-  /// \brief Destructor of graph.
   ~Graph();
-  /// \brief Get graph's modeltype.
-  ///
-  /// \return Model type.
+
   enum ModelType ModelType() const;
-  /// \brief Operator equal.
   bool operator==(std::nullptr_t) const;
-  /// \brief Operator not equal.
   bool operator!=(std::nullptr_t) const;
 
  private:

mindspore/include/api/kernel.h

@@ -28,35 +28,22 @@
 namespace mindspore::kernel {
 class MS_API Kernel : public IKernel<schema::Primitive> {
  public:
-  /// \brief Constructor of Kernel.
   Kernel() = default;
-  /// \brief Constructor of Kernel.
-  ///
-  /// \param[in] inputs Input tensors.
-  ///
-  /// \param[in] outputs Output tensors.
-  ///
-  /// \param[in] primitive The primitive of kernel.
-  ///
-  /// \param[in] context The context created.
   Kernel(const std::vector<mindspore::MSTensor> &inputs, const std::vector<mindspore::MSTensor> &outputs,
          const schema::Primitive *primitive, const mindspore::Context *ctx)
       : IKernel<schema::Primitive>(inputs, outputs, primitive, ctx) {
     Initialize();
   }
-  /// \brief Destructor of Kernel.
   virtual ~Kernel() = default;
-  /// \brief infer kernel's shape.
-  ///
-  /// \return status.
+
   int InferShape() override;
   /// \brief obtain kernel's type.
   ///
   /// \return kernel's type.
   virtual schema::PrimitiveType type() const { return type_; }
-  /// \brief Obtain kernel's quant type.
+  /// \brief obtain kernel's quant type.
   ///
-  /// \return Kernel's quant type.
+  /// \return kernel's quant type.
   virtual schema::QuantType quant_type() const { return quant_type_; }
   /// \brief obtain the primitive of kernel generated by flatbuffers.
  protected:

mindspore/include/api/kernel_api.h

@@ -28,7 +28,6 @@ namespace kernel {
 /// \brief The Kernel class is used to define a MindSpore Kernel.
 class MS_API MSKernel {
  public:
-  /// \brief Constructor of MSKernel.
   MSKernel() = default;
   /// \brief Constructor.
   ///
@@ -131,17 +130,12 @@ class MS_API MSKernel {
   /// \param[in] key define the kernel's attribute key.
   /// \param[in] value define the kernel's attribute value.
   void SetAttr(const std::string &key, const std::string &value) { attrs_[key] = value; }
-  /// \brief kernel's name.
+
   std::string name_;
-  /// \brief kernel's context.
   const mindspore::Context *context_ = nullptr;
-  /// \brief kernel's inputs.
   std::vector<mindspore::MSTensor> inputs_;
-  /// \brief kernel's outputs.
   std::vector<mindspore::MSTensor> outputs_;
-  /// \brief kernel's attrs.
   std::map<std::string, std::string> attrs_;
-  /// \brief kernel's config.
   const std::map<std::string, std::map<std::string, std::string>> *config_ = nullptr;
 };
 
@@ -149,7 +143,6 @@ class MS_API MSKernel {
 template <typename Primitive>
 class MS_API IKernel : public MSKernel {
  public:
-  /// \brief Constructor of IKernel.
   IKernel() = default;
   /// \brief Constructor.
   ///
@@ -168,7 +161,6 @@ class MS_API IKernel : public MSKernel {
   const Primitive *primitive() const { return this->primitive_; }
 
  protected:
-  /// \brief kernel's primitive, which is deserialized from flatbuffers.
   const Primitive *primitive_ = nullptr;
 };
 }  // namespace kernel

mindspore/include/api/metrics/accuracy.h

@@ -25,19 +25,10 @@ constexpr int METRICS_MULTILABEL = 1;
 
 class MS_API AccuracyMetrics : public Metrics {
  public:
-  /// \brief Constructor of AccuracyMetrics.
-  ///
-  /// \param[in] accuracy_metrics The metrics of accuracy.
-  /// \param[in] input_indexes The indexes of inputs.
-  /// \param[in] output_indexes The indexes of outputs.
-
   explicit AccuracyMetrics(int accuracy_metrics = METRICS_CLASSIFICATION, const std::vector<int> &input_indexes = {1},
                            const std::vector<int> &output_indexes = {0});
-  /// \brief Destructor of AccuracyMetrics.
   virtual ~AccuracyMetrics();
-  /// \brief Clear the accuracy metrics.
   void Clear() override;
-  /// \brief Eval function.
   float Eval() override;
 };
 

mindspore/include/api/model.h

@@ -40,9 +40,7 @@ class Dataset;
 /// \brief The Model class is used to define a MindSpore model, facilitating computational graph management.
 class MS_API Model {
  public:
-  /// \brief Constructor of Model.
   Model();
-  /// \brief Destructor of Model.
   ~Model();
 
   /// \brief Build a model from model buffer so that it can run on a device.
@@ -363,9 +361,6 @@ class MS_API Model {
   /// \return Status of operation.
   Status Evaluate(std::shared_ptr<dataset::Dataset> ds, std::vector<TrainCallBack *> cbs);
 
-  /// \brief Performs the implication.
-  ///
-  /// \return the implication of the model.
   const std::shared_ptr<ModelImpl> impl() const { return impl_; }
 
   /// \brief Get model info by key
@@ -374,6 +369,7 @@ class MS_API Model {
   ///
   /// \return The value of the model info associated with the given key.
   inline std::string GetModelInfo(const std::string &key);
+
   /// \brief Finish the model. (Only used for mindspore_lite's ascend backend.)
   ///
   /// \return Status of the operation.

mindspore/include/api/model_group.h

@@ -41,11 +41,7 @@ enum class ModelGroupFlag : int {
 
 class MS_API ModelGroup {
  public:
-  /// \brief Constructor of ModelGroup.
-  ///
-  /// \param[in] flags The flags of model group.
   explicit ModelGroup(ModelGroupFlag flags = ModelGroupFlag::kShareWorkspace);
-  /// \brief Destructor of ModelGroup.
   ~ModelGroup() = default;
 
   /// \brief Add models that require shared workspace memory.

mindspore/include/api/model_parallel_runner.h

@@ -28,9 +28,7 @@ namespace mindspore {
 class MS_API RunnerConfig {
  public:
   struct Data;
-  /// \brief Constructor of RunnerConfig.
   RunnerConfig();
-  /// \brief Destructor of RunnerConfig.
   ~RunnerConfig();
 
   /// \brief Set the number of workers at runtime. Only valid for ModelParallelRunner.