mindspore 2.3.0__cp310-cp310-win_amd64.whl

mindspore/include/api/allocator.h

@@ -0,0 +1,97 @@
+/**
+ * Copyright 2021 Huawei Technologies Co., Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed 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_ALLOCATOR_H
+#define MINDSPORE_INCLUDE_API_ALLOCATOR_H
+
+#include <memory>
+#include "include/api/types.h"
+
+namespace mindspore {
+/// \brief Allocator defined a memory pool for malloc memory and free memory dynamically.
+class MS_API Allocator {
+ public:
+  /// \brief Destructor of MindSpore Allocator.
+  virtual ~Allocator() = default;
+
+  /// \brief Method to request memory.
+  ///
+  /// \param[in] size Define the memory size to request.
+  virtual void *Malloc(size_t size) = 0;
+
+  /// \brief Method to request memory.
+  ///
+  /// \param[in] weight Defines the width of memory to request
+  /// \param[in] height Defines the height of memory to request
+  /// \param[in] type Defines the data type of memory to request
+  virtual void *Malloc(size_t weight, size_t height, DataType type) {
+    return nullptr;
+  }
+
+  /// \brief Method to free memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  virtual void Free(void *ptr) = 0;
+
+  /// \brief Reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  ///
+  /// \return Reference count of a certain memory currently.
+  virtual int RefCount(void *ptr) = 0;
+
+  /// \brief Set reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  /// \param[in] ref_count Define the reference count to set.
+  ///
+  /// \return Reference count of a certain memory after setting.
+  virtual int SetRefCount(void *ptr, int ref_count) = 0;
+
+  /// \brief Decrease the reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  /// \param[in] ref_count Define the reference count to reduce.
+  ///
+  /// \return Reference count of a certain memory after decreating.
+  virtual int DecRefCount(void *ptr, int ref_count) = 0;
+
+  /// \brief Increase the reference count of a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory.
+  /// \param[in] ref_count Define the reference count to increase.
+  ///
+  /// \return Reference count of a certain memory after increasing.
+  virtual int IncRefCount(void *ptr, int ref_count) = 0;
+
+  /// \brief Static method to create an allocator.
+  ///
+  /// \return Smart pointer of an allocator.
+  static std::shared_ptr<Allocator> Create();
+
+  /// \brief Prepare a certain memory.
+  ///
+  /// \param[in] ptr Define the pointer of a certain memory to prepare.
+  ///
+  /// \return Pointer of ready memory.
+  virtual void *Prepare(void *ptr) { return ptr; }
+
+ protected:
+  // memory aligned bytes
+  size_t aligned_size_ = 32;
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_ALLOCATOR_H

mindspore/include/api/callback/callback.h

@@ -0,0 +1,93 @@
+/**
+ * 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.
+ * 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_CALLBACK_CALLBACK_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_CALLBACK_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+#include "include/api/data_type.h"
+#include "include/api/dual_abi_helper.h"
+#include "include/api/types.h"
+
+namespace mindspore {
+class Model;
+class ModelImpl;
+class CallbackImpl;
+
+using GraphPoint = std::pair<int, float>;
+
+struct MS_API TrainCallBackData {
+  TrainCallBackData(bool train_mode, int epoch, int step, Model *model)
+      : train_mode_(train_mode), epoch_(epoch), step_(step), model_(model) {}
+
+  bool train_mode_;       /**< training mode of LiteSession object */
+  unsigned int epoch_;    /**< the current training epoch (starts at 0) */
+  unsigned int step_ = 0; /**< the current step within the epoch */
+  Model *model_;          /**< pointer to the Model object */
+};
+
+enum CallbackRetValue : uint32_t { kContinue = 0, kStopTraining = 1, kExit = 2, kUnknownRetValue = 0xFFFFFFFF };
+
+class MS_API TrainCallBack {
+ public:
+  virtual ~TrainCallBack() = default;
+
+  /// \brief This method is called once before the network executing
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void Begin(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called once following the network execution
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void End(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called at the beginning of each epoch
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void EpochBegin(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called after the run of each epoch
+  ///
+  /// \param[in] cb_data info about current execution
+  ///
+  /// \return indication if to continue in the train loop:
+  ///         RET_CONTINUE -- continue training
+  ///         RET_STOP_TRAINING -- stop training (e.g., due to achieved accuracy)
+  ///         RET_EXIT -- Exit training (due to error of some sort)
+  virtual CallbackRetValue EpochEnd(const TrainCallBackData &cb_data) { return kContinue; }
+
+  /// \brief This method is called at the beginning of each step
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void StepBegin(const TrainCallBackData &cb_data) {}
+
+  /// \brief This method is called after each step is ran
+  ///
+  /// \param[in] cb_data info about current execution
+  virtual void StepEnd(const TrainCallBackData &cb_data) {}
+
+ protected:
+  friend class Model;
+  friend class ModelImpl;
+  CallbackImpl *callback_impl_ = nullptr;
+};
+
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_CALLBACK_H

mindspore/include/api/callback/ckpt_saver.h

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ * 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_CALLBACK_CKPT_SAVER_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_CKPT_SAVER_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include "include/api/callback/callback.h"
+#include "include/api/dual_abi_helper.h"
+
+namespace mindspore {
+
+class MS_API CkptSaver : public TrainCallBack {
+ public:
+  inline CkptSaver(int save_every_n, const std::string &filename_prefix);
+  virtual ~CkptSaver();
+
+ private:
+  CkptSaver(int save_every_n, const std::vector<char> &filename_prefix);
+};
+
+CkptSaver::CkptSaver(int save_every_n, const std::string &filename_prefix)
+    : CkptSaver(save_every_n, StringToChar(filename_prefix)) {}
+
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_CKPT_SAVER_H

mindspore/include/api/callback/loss_monitor.h

@@ -0,0 +1,33 @@
+/**
+ * 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.
+ * 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_CALLBACK_LOSS_MONITOR_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_LOSS_MONITOR_H
+
+#include <cstddef>
+#include <vector>
+#include <utility>
+#include "include/api/callback/callback.h"
+
+namespace mindspore {
+
+class MS_API LossMonitor : public TrainCallBack {
+ public:
+  explicit LossMonitor(int print_every_n_steps = INT_MAX);
+  virtual ~LossMonitor();
+  const std::vector<GraphPoint> &GetLossPoints();
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_LOSS_MONITOR_H

mindspore/include/api/callback/lr_scheduler.h

@@ -0,0 +1,51 @@
+/**
+ * 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.
+ * 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_CALLBACK_LR_SCHEDULER_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_LR_SCHEDULER_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include "include/api/callback/callback.h"
+
+namespace mindspore {
+
+constexpr int DONT_UPDATE_LR = 0;
+constexpr int UPDATE_LR = 1;
+
+using LR_Lambda = std::function<int(float *lr, int epoch, void *cb_data)>;
+
+/// \brief Multiply the LR by a factor of gamma every epoch
+MS_API int MultiplicativeLRLambda(float *lr, int epoch, void *multiplication);
+
+/// \brief Multiply the LR by a factor of gamma every step_size
+MS_API int StepLRLambda(float *lr, int epoch, void *step_size);
+struct MS_API StepLRLambda {
+  StepLRLambda(int step, float g) : step_size(step), gamma(g) {}
+
+  int step_size;  // period of LR decay
+  float gamma;    // LR decay factor
+};
+
+class MS_API LRScheduler : public TrainCallBack {
+ public:
+  explicit LRScheduler(LR_Lambda lambda_func, void *lr_cb_data = nullptr, int step = 1);
+  virtual ~LRScheduler();
+};
+
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_LR_SCHEDULER_H

mindspore/include/api/callback/time_monitor.h

@@ -0,0 +1,34 @@
+/**
+ * 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.
+ * 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_CALLBACK_TIME_MONITOR_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_TIME_MONITOR_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include "include/api/callback/callback.h"
+
+namespace mindspore {
+
+class MS_API TimeMonitor : public TrainCallBack {
+ public:
+  virtual ~TimeMonitor() = default;
+  void EpochBegin(const TrainCallBackData &cb_data) override;
+  CallbackRetValue EpochEnd(const TrainCallBackData &cb_data) override;
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_TIME_MONITOR_H

mindspore/include/api/callback/train_accuracy.h

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ * 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_CALLBACK_TRAIN_ACCURACY_H
+#define MINDSPORE_INCLUDE_API_CALLBACK_TRAIN_ACCURACY_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include <utility>
+#include "include/api/callback/callback.h"
+#include "include/api/metrics/accuracy.h"
+
+namespace mindspore {
+
+class MS_API TrainAccuracy : public TrainCallBack {
+ public:
+  explicit TrainAccuracy(int print_every_n = INT_MAX, int accuracy_metrics = METRICS_CLASSIFICATION,
+                         const std::vector<int> &input_indexes = {1}, const std::vector<int> &output_indexes = {0});
+  virtual ~TrainAccuracy();
+  const std::vector<GraphPoint> &GetAccuracyPoints();
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CALLBACK_TRAIN_ACCURACY_H

mindspore/include/api/cell.h

@@ -0,0 +1,90 @@
+/**
+ * Copyright 2020 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_CELL_H
+#define MINDSPORE_INCLUDE_API_CELL_H
+#include <string>
+#include <vector>
+#include <map>
+#include <memory>
+#include "include/api/status.h"
+#include "include/api/types.h"
+#include "include/api/graph.h"
+
+namespace mindspore {
+class InputAndOutput;
+class Context;
+using Input = InputAndOutput;
+using Output = InputAndOutput;
+
+class MS_API CellBase {
+ public:
+  CellBase() = default;
+  virtual ~CellBase() = default;
+  virtual std::vector<Output> Construct(const std::vector<Input> &inputs) { return {}; }
+  virtual std::shared_ptr<CellBase> Clone() const = 0;
+  virtual Status Run(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) { return kSuccess; }
+  std::vector<Output> operator()(const std::vector<Input> &inputs) const;
+};
+
+template <class T>
+class MS_API Cell : public CellBase {
+ public:
+  virtual ~Cell() = default;
+  std::shared_ptr<CellBase> Clone() const override { return std::make_shared<T>(static_cast<const T &>(*this)); }
+};
+
+class MS_API GraphCell final : public Cell<GraphCell> {
+ public:
+  class GraphImpl;
+
+  GraphCell() = default;
+  ~GraphCell() override = default;
+
+  explicit GraphCell(const Graph &graph);
+  explicit GraphCell(Graph &&graph);
+  explicit GraphCell(const std::shared_ptr<Graph> &graph);
+
+  void SetContext(const std::shared_ptr<Context> &context);
+  const std::shared_ptr<Graph> &GetGraph() const { return graph_; }
+  Status Run(const std::vector<MSTensor> &inputs, std::vector<MSTensor> *outputs) override;
+  std::vector<MSTensor> GetInputs();
+  std::vector<MSTensor> GetOutputs();
+  Status Load(uint32_t device_id);
+
+ private:
+  friend class Model;
+
+  std::shared_ptr<Graph> graph_;
+  std::shared_ptr<GraphImpl> executor_;
+};
+
+class MS_API InputAndOutput {
+ public:
+  InputAndOutput();
+  ~InputAndOutput() = default;
+
+  InputAndOutput(const std::shared_ptr<CellBase> &cell, const std::vector<InputAndOutput> &prev, int32_t index);
+
+  int32_t GetIndex() const { return index_; }
+  void SetIndex(int32_t index) { index_ = index; }
+
+ private:
+  std::shared_ptr<CellBase> cell_;
+  std::vector<InputAndOutput> prev_;
+  int32_t index_ = 0;
+};
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CELL_H

mindspore/include/api/cfg.h

@@ -0,0 +1,82 @@
+/**
+ * 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.
+ * 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_CFG_H
+#define MINDSPORE_INCLUDE_API_CFG_H
+
+#include <cstddef>
+#include <string>
+#include <vector>
+#include <memory>
+#include "include/api/data_type.h"
+#include "include/api/dual_abi_helper.h"
+#include "include/api/types.h"
+
+namespace mindspore {
+constexpr int iter_th = 1000;
+class MS_API MixPrecisionCfg {
+ public:
+  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;
+  }
+  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_;
+  }
+  ~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  */
+};
+
+class MS_API TrainCfg {
+ public:
+  TrainCfg() = default;
+  TrainCfg(const TrainCfg &rhs) {
+    this->loss_name_ = rhs.loss_name_;
+    this->mix_precision_cfg_ = rhs.mix_precision_cfg_;
+    this->accumulate_gradients_ = rhs.accumulate_gradients_;
+  }
+  ~TrainCfg() = default;
+
+  /// \brief obtain part of the name that identify a loss kernel.
+  ///
+  /// \return loss_name.
+  inline std::vector<std::string> GetLossName() const;
+  /// \brief Set part of the name that identify a loss kernel.
+  ///
+  /// \param[in] loss_name define part of the name that identify a loss kernel.
+  inline void SetLossName(const std::vector<std::string> &loss_name);
+
+  OptimizationLevel optimization_level_ = kO0;
+  MixPrecisionCfg mix_precision_cfg_; /**< Mix precision configuration */
+  bool accumulate_gradients_ = false;
+
+ private:
+  std::vector<std::vector<char>> loss_name_ = VectorStringToChar({"loss_fct", "_loss_fn", "SigmoidCrossEntropy"});
+};
+
+std::vector<std::string> TrainCfg::GetLossName() const { return VectorCharToString(loss_name_); }
+void TrainCfg::SetLossName(const std::vector<std::string> &loss_name) { loss_name_ = VectorStringToChar(loss_name); }
+}  // namespace mindspore
+#endif  // MINDSPORE_INCLUDE_API_CFG_H