mindspore 2.6.0rc1__cp311-cp311-win_amd64.whl → 2.7.0__cp311-cp311-win_amd64.whl

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;
 };
 

mindspore/include/api/model.h

@@ -40,7 +40,9 @@ 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.
@@ -361,6 +363,9 @@ 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
@@ -369,7 +374,9 @@ 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.
   // release inference resourcec, only used for mindspore_lite's ascend backend now.
   Status Finalize();
 

mindspore/include/api/model_group.h

@@ -41,7 +41,11 @@ 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,7 +28,9 @@ 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.

mindspore/include/api/status.h

@@ -128,37 +128,75 @@ enum StatusCode : uint32_t {
 
 class MS_API Status {
  public:
+  /// \brief Constructor of Status.
   Status();
+  /// \brief Constructor of Status.
+  ///
+  /// \param[in] status_code Status code.
+  ///
+  /// \param[in] status_msg Status message.
   inline Status(enum StatusCode status_code, const std::string &status_msg = "");  // NOLINT(runtime/explicit)
+  /// \brief Constructor of Status.
   inline Status(const StatusCode code, int line_of_code, const char *file_name, const std::string &extra = "");
-
+  /// \brief Destructor of Status.
   ~Status() = default;
-
+  /// \brief Status code of status.
+  ///
+  /// \return Enum of status code.
   enum StatusCode StatusCode() const;
+  /// \brief Exchange status to string.
+  ///
+  /// \return Status code exchanged to string.
   inline std::string ToString() const;
-
+  /// \brief Get line of status code.
+  ///
+  /// \return Line of code to get.
   int GetLineOfCode() const;
+  /// \brief Get file name of status.
+  ///
+  /// \return File name to get.
   inline std::string GetFileName() const;
+  /// \brief Get error description of status.
+  ///
+  /// \return Error description to get.
   inline std::string GetErrDescription() const;
+  /// \brief Get error description of status.
+  ///
+  /// \param[in] err_description Error description to be set.
   inline std::string SetErrDescription(const std::string &err_description);
+  /// \brief Status message to be set.
+  ///
+  /// \param[in] status_msg Status message to be set.
   inline void SetStatusMsg(const std::string &status_msg);
-
+  /// \brief Operator <<.
   MS_API friend std::ostream &operator<<(std::ostream &os, const Status &s);
-
+  /// \brief Operator ==.
   bool operator==(const Status &other) const;
+  /// \brief Operator ==.
   bool operator==(enum StatusCode other_code) const;
+  /// \brief Operator !=.
   bool operator!=(const Status &other) const;
+  /// \brief Operator !=.
   bool operator!=(enum StatusCode other_code) const;
-
+  /// \brief Operator bool().
   explicit operator bool() const;
+  /// \brief Operator int().
   explicit operator int() const;
-
+  /// \brief Getting back the status of OK.
+  ///
+  /// \return Status Code of ok.
   static Status OK();
-
+  /// \brief Getting back if it is ok.
+  ///
+  /// \return True if it is ok.
   bool IsOk() const;
-
+  /// \brief Getting back if it is error.
+  ///
+  /// \return True if it is error.
   bool IsError() const;
-
+  /// \brief Getting back the code as string.
+  ///
+  /// \return The code name as string type.
   static inline std::string CodeAsString(enum StatusCode c);
 
  private:

mindspore/include/api/types.h

@@ -74,6 +74,7 @@ class Allocator;
 /// \brief The MSTensor class defines a tensor in MindSpore.
 class MS_API MSTensor {
  public:
+  /// \brief Impl class of MSTensor.
   class Impl;
   /// \brief Creates a MSTensor object, whose data need to be copied before accessed by Model, must be used in pairs
   /// with DestroyTensorPtr.
@@ -161,13 +162,17 @@ class MS_API MSTensor {
   ///
   /// \param[in] tensor A MSTensor object.
   static void DestroyTensorPtr(MSTensor *tensor) noexcept;
-
+  /// \brief Constructor of MSTensor.
   MSTensor();
+  /// \brief Constructor of MSTensor.
   explicit MSTensor(const std::shared_ptr<Impl> &impl);
+  /// \brief Constructor of MSTensor.
   // if malloc data, user need to free after constructing MSTensor, else memory leak.
   inline MSTensor(const std::string &name, DataType type, const std::vector<int64_t> &shape, const void *data,
                   size_t data_len);
+  /// \brief Constructor of MSTensor.
   explicit MSTensor(std::nullptr_t);
+  /// \brief Destructor of MSTensor.
   ~MSTensor();
 
   /// \brief Obtains the name of the MSTensor.
@@ -243,14 +248,14 @@ class MS_API MSTensor {
 
   /// \brief Get the boolean value that indicates whether the MSTensor equals tensor.
   ///
-  /// \param[in] another MSTensor.
+  /// \param[in] tensor MSTensor.
   ///
   /// \return The boolean value that indicates whether the MSTensor equals tensor.
   bool operator==(const MSTensor &tensor) const;
 
   /// \brief Get the boolean value that indicates whether the MSTensor not equals tensor.
   ///
-  /// \param[in] another MSTensor.
+  /// \param[in] tensor MSTensor.
   ///
   /// \return The boolean value that indicates whether the MSTensor not equals tensor.
   bool operator!=(const MSTensor &tensor) const;