mindspore 2.7.0rc1__cp310-cp310-win_amd64.whl → 2.7.1__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}
+                   'aoe_job_type': False, 'aclnn_cache': False}
 
 
 def op_compile(value):
@@ -121,3 +121,37 @@ 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/{profiler/common/validator → graph}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2025 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.
@@ -12,3 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
+
+"""Graph optimization and transformation functionality."""
+
+from mindspore.graph.custom_pass import register_custom_pass
+
+__all__ = [
+    "register_custom_pass"
+]

mindspore/graph/custom_pass.py

@@ -0,0 +1,55 @@
+# Copyright 2025 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.
+# ============================================================================
+
+"""
+Experimental custom pass registration functionality.
+
+This module provides experimental APIs for registering custom optimization passes.
+These APIs are subject to change and should be used with caution in production code.
+"""
+
+import mindspore._c_expression as _c_expression
+
+
+def register_custom_pass(pass_name: str, plugin_so_path: str, device: str = "all", stage: str = "") -> bool:
+    """Register a custom pass plugin.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        pass_name (str): Name of the pass expected to be provided by the plugin.
+        plugin_so_path (str): Absolute path to the plugin shared library (.so file).
+        device (str): Target device for the pass. Supported values: "cpu", "gpu", "ascend", or "all".
+            Default: "all".
+        stage (str): Pass stage. Reserved field for future use. Default: "".
+
+    Returns:
+        bool: True if plugin loaded successfully, False otherwise.
+
+    Examples:
+        >>> import mindspore.graph as graph
+        >>> # Register a custom optimization pass
+        >>> success = graph.register_custom_pass(
+        ...     pass_name="my_fusion_pass",
+        ...     plugin_so_path="/path/to/my_plugin.so",
+        ...     device="ascend"
+        ... )
+        >>> print(f"Registration successful: {success}")
+    """
+    return _c_expression.register_custom_pass(pass_name, plugin_so_path, device, stage)
+
+
+__all__ = ["register_custom_pass"]

mindspore/include/api/cell.h

@@ -31,7 +31,9 @@ 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.
   ///
@@ -63,12 +65,21 @@ 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.
   ///
@@ -109,12 +120,25 @@ 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,35 +28,50 @@ 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;
 
-  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  */
+  /// \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;
 };
 
 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.
@@ -67,9 +82,11 @@ 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;
-  MixPrecisionCfg mix_precision_cfg_; /**< Mix precision configuration */
+  /// \brief Mix precision configuration.
+  MixPrecisionCfg mix_precision_cfg_;
+  /// \brief If accumulate gradients is used.
   bool accumulate_gradients_ = false;
 
  private:

mindspore/include/api/context.h

@@ -50,6 +50,7 @@ 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,7 +129,6 @@ 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.
@@ -139,7 +138,6 @@ 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,6 +28,11 @@
 
 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>();
@@ -35,7 +40,11 @@ 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 = "";
@@ -43,43 +52,71 @@ 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;
@@ -88,7 +125,11 @@ 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;
@@ -97,7 +138,11 @@ 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;
@@ -107,7 +152,11 @@ 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;
@@ -117,7 +166,11 @@ 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;
@@ -127,7 +180,11 @@ 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;
@@ -137,7 +194,11 @@ 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;
@@ -147,7 +208,11 @@ 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;
@@ -156,7 +221,11 @@ 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;
@@ -165,7 +234,11 @@ 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) {
@@ -177,7 +250,11 @@ 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;
@@ -191,7 +268,11 @@ 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,14 +27,27 @@ 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,22 +28,35 @@
 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,6 +28,7 @@ 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.
   ///
@@ -130,12 +131,17 @@ 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;
 };
 
@@ -143,6 +149,7 @@ class MS_API MSKernel {
 template <typename Primitive>
 class MS_API IKernel : public MSKernel {
  public:
+  /// \brief Constructor of IKernel.
   IKernel() = default;
   /// \brief Constructor.
   ///
@@ -161,6 +168,7 @@ 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,10 +25,19 @@ 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;
 };