mindspore 2.2.14__cp38-cp38-manylinux1_x86_64.whl → 2.3.0rc2__cp38-cp38-manylinux1_x86_64.whl

mindspore/include/c_api/model_c.h

@@ -26,6 +26,8 @@ extern "C" {
 
 typedef void *MSModelHandle;
 
+typedef void *MSTrainCfgHandle;
+
 typedef struct MSTensorHandleArray {
   size_t handle_num;
   MSTensorHandle *handle_list;
@@ -168,6 +170,177 @@ MS_API MSTensorHandle MSModelGetInputByTensorName(const MSModelHandle model, con
 /// \return The output tensor handle with the given name, if the name is not found, an NULL is returned.
 MS_API MSTensorHandle MSModelGetOutputByTensorName(const MSModelHandle model, const char *tensor_name);
 
+/// \brief Create a TrainCfg object. Only valid for Lite Train.
+///
+/// \return TrainCfg object handle.
+MS_API MSTrainCfgHandle MSTrainCfgCreate();
+
+/// \brief Destroy the train_cfg object. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+MS_API void MSTrainCfgDestroy(MSTrainCfgHandle *train_cfg);
+
+/// \brief Obtains part of the name that identify a loss kernel. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+/// \param[in] num The num of loss_name.
+///
+/// \return loss_name.
+MS_API char **MSTrainCfgGetLossName(MSTrainCfgHandle train_cfg, size_t *num);
+
+/// \brief Set part of the name that identify a loss kernel. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+/// \param[in] loss_name define part of the name that identify a loss kernel.
+/// \param[in] num The num of loss_name.
+MS_API void MSTrainCfgSetLossName(MSTrainCfgHandle train_cfg, const char **loss_name, size_t num);
+
+/// \brief Obtains optimization level of the train_cfg. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+///
+/// \return MSOptimizationLevel.
+MS_API MSOptimizationLevel MSTrainCfgGetOptimizationLevel(MSTrainCfgHandle train_cfg);
+
+/// \brief Set optimization level of the train_cfg. Only valid for Lite Train.
+///
+/// \param[in] train_cfg TrainCfg object handle.
+/// \param[in] level The optimization level of train_cfg.
+MS_API void MSTrainCfgSetOptimizationLevel(MSTrainCfgHandle train_cfg, MSOptimizationLevel level);
+
+/// \brief Build the train model from model buffer so that it can run on a device. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] model_data Define the buffer read from a model file.
+/// \param[in] data_size Define bytes number of model file buffer.
+/// \param[in] model_type Define The type of model file.
+/// \param[in] model_context Define the context used to store options during execution.
+/// \param[in] train_cfg Define the config used by training.
+///
+/// \return MSStatus.
+MS_API MSStatus MSTrainModelBuild(MSModelHandle model, const void *model_data, size_t data_size, MSModelType model_type,
+                                  const MSContextHandle model_context, const MSTrainCfgHandle train_cfg);
+
+/// \brief Build the train model from model file buffer so that it can run on a device. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] model_path Define the model path.
+/// \param[in] model_type Define The type of model file.
+/// \param[in] model_context Define the context used to store options during execution.
+/// \param[in] train_cfg Define the config used by training.
+///
+/// \return MSStatus.
+MS_API MSStatus MSTrainModelBuildFromFile(MSModelHandle model, const char *model_path, MSModelType model_type,
+                                          const MSContextHandle model_context, const MSTrainCfgHandle train_cfg);
+
+/// \brief Train model by step. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] before CallBack before predict.
+/// \param[in] after CallBack after predict.
+///
+/// \return MSStatus.
+MS_API MSStatus MSRunStep(MSModelHandle model, const MSKernelCallBackC before, const MSKernelCallBackC after);
+
+/// \brief Sets the Learning Rate of the training. Only valid for Lite Train.
+///
+/// \param[in] learning_rate to set.
+///
+/// \return MSStatus of operation.
+MS_API MSStatus MSModelSetLearningRate(MSModelHandle model, float learning_rate);
+
+/// \brief Obtains the Learning Rate of the optimizer. Only valid for Lite Train.
+///
+/// \return Learning rate. 0.0 if no optimizer was found.
+MS_API float MSModelGetLearningRate(MSModelHandle model);
+
+/// \brief Obtains all weights tensors of the model. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+///
+/// \return The vector that includes all gradient tensors.
+MS_API MSTensorHandleArray MSModelGetWeights(MSModelHandle model);
+
+/// \brief update weights tensors of the model. Only valid for Lite Train.
+///
+/// \param[in] new_weights A vector new weights.
+///
+/// \return MSStatus
+MS_API MSStatus MSModelUpdateWeights(MSModelHandle model, const MSTensorHandleArray new_weights);
+
+/// \brief Get the model running mode.
+///
+/// \param[in] model Model object handle.
+///
+/// \return Is Train Mode or not.
+MS_API bool MSModelGetTrainMode(MSModelHandle model);
+
+/// \brief Set the model running mode. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] train True means model runs in Train Mode, otherwise Eval Mode.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelSetTrainMode(MSModelHandle model, bool train);
+
+/// \brief Setup training with virtual batches. Only valid for Lite Train.
+///
+/// \param[in] model Model object handle.
+/// \param[in] virtual_batch_multiplier - virtual batch multiplier, use any number < 1 to disable.
+/// \param[in] lr - learning rate to use for virtual batch, -1 for internal configuration.
+/// \param[in] momentum - batch norm momentum to use for virtual batch, -1 for internal configuration.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelSetupVirtualBatch(MSModelHandle model, int virtual_batch_multiplier, float lr, float momentum);
+
+/// \brief Export training model from file. Only valid for Lite Train.
+///
+/// \param[in] model The model data.
+/// \param[in] model_type The model file type.
+/// \param[in] model_file The 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
+/// empty, and export the complete reasoning model.
+/// \param[in] num The number of output_tensor_name.
+///
+/// \return MSStatus.
+MS_API MSStatus MSExportModel(MSModelHandle model, MSModelType model_type, const char *model_file,
+                              MSQuantizationType quantization_type, bool export_inference_only,
+                              char **output_tensor_name, size_t num);
+
+/// \brief Export training model from buffer. Only valid for Lite Train.
+///
+/// \param[in] model The model data.
+/// \param[in] model_type The model file type.
+/// \param[in] model_data The exported model buffer.
+/// \param[in] data_size The exported model buffer size.
+/// \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.
+/// \param[in] num The number of output_tensor_name.
+///
+/// \return MSStatus.
+MS_API MSStatus MSExportModelBuffer(MSModelHandle model, MSModelType model_type, char **model_data, size_t *data_size,
+                                    MSQuantizationType quantization_type, bool export_inference_only,
+                                    char **output_tensor_name, size_t num);
+
+/// \brief Export model's weights, which can be used in micro only. Only valid for Lite Train.
+///
+/// \param[in] model The model data.
+/// \param[in] model_type The model file type.
+/// \param[in] weight_file The path of exported weight file.
+/// \param[in] is_inference Whether to export weights from a reasoning model. Currently, only support this is `true`.
+/// \param[in] enable_fp16 Float-weight is whether to be saved in float16 format.
+/// \param[in] changeable_weights_name The set the name of these weight tensors, whose shape is changeable.
+/// \param[in] num The number of changeable_weights_name.
+///
+/// \return MSStatus.
+MS_API MSStatus MSExportWeightsCollaborateWithMicro(MSModelHandle model, MSModelType model_type,
+                                                    const char *weight_file, bool is_inference, bool enable_fp16,
+                                                    char **changeable_weights_name, size_t num);
+
 #ifdef __cplusplus
 }
 #endif

mindspore/include/c_api/ms/base/types.h

@@ -250,6 +250,7 @@ typedef enum PadMode {
   PAD = 0,
   SAME = 1,
   VALID = 2,
+  FULL = 3,
 } PadMode;
 
 typedef enum Format {

mindspore/include/c_api/types_c.h

@@ -42,6 +42,25 @@ typedef enum MSDeviceType {
   kMSDeviceTypeInvalid = 100,
 } MSDeviceType;
 
+typedef enum MSOptimizationLevel {
+  /** Do not change */
+  kMSKO0 = 0,
+  /** Cast network to float16, keep batchnorm and loss in float32 */
+  kMSKO2 = 2,
+  /** Cast network to float16, including bacthnorm */
+  kMSKO3 = 3,
+  /** Choose optimization based on device */
+  kMSKAUTO = 4,
+  kMSKOPTIMIZATIONTYPE = 0xFFFFFFFF
+} MSOptimizationLevel;
+
+typedef enum MSQuantizationType {
+  kMSNO_QUANT = 0,
+  kMSWEIGHT_QUANT = 1,
+  kMSFULL_QUANT = 2,
+  kMSUNKNOWN_QUANT_TYPE = 0xFFFFFFFF
+} MSQuantizationType;
+
 #ifdef __cplusplus
 }
 #endif

mindspore/include/dataset/execute.h

@@ -152,7 +152,7 @@ class DATASET_API Execute {
 
  protected:
   /// \brief The function to convert TensorTransforms into TensorOperations and then build TensorOps.
-  Status BuildTransforms();
+  Status BuildTransforms(std::vector<std::shared_ptr<TensorOp>> *transforms_rt);
 
   /// \brief The function to convert a TensorTransform object into a TensorOperation object.
   Status ParseTransforms();
@@ -177,8 +177,6 @@ class DATASET_API Execute {
   device::DeviceContext *device_context_ = nullptr;
   size_t stream_id_;
 #endif
-
-  std::vector<std::shared_ptr<TensorOp>> transforms_rt_;
 };
 
 class PyExecute : public Execute {

mindspore/include/mindapi/base/format.h

@@ -25,36 +25,138 @@ namespace mindspore {
 enum Format : int64_t {
   DEFAULT_FORMAT = -1,
   NCHW = 0,
-  NHWC = 1,
-  NHWC4 = 2,
-  HWKC = 3,
-  HWCK = 4,
-  KCHW = 5,
-  CKHW = 6,
-  KHWC = 7,
-  CHWK = 8,
-  HW = 9,
-  HW4 = 10,
-  NC = 11,
-  NC4 = 12,
-  NC4HW4 = 13,
-  NUM_OF_FORMAT = 14,
-  NCDHW = 15,
-  NWC = 16,
-  NCW = 17,
-  NDHWC = 18,
-  NC8HW8 = 19
+  NHWC,
+  NHWC4,
+  HWKC,
+  HWCK,
+  KCHW,
+  CKHW,
+  KHWC,
+  CHWK,
+  HW,
+  HW4,
+  NC,
+  NC4,
+  NC4HW4,
+  NCDHW,
+  NWC,
+  NCW,
+  NDHWC,
+  NC8HW8,
+  FRACTAL_NZ,
+  ND,         // Nd Tensor
+  NC1HWC0,    // NC1HWC0
+  FRACTAL_Z,  // FRACTAL_Z
+  NC1C0HWPAD,
+  NHWC1C0,
+  FSR_NCHW,
+  FRACTAL_DECONV,
+  C1HWNC0,
+  FRACTAL_DECONV_TRANSPOSE,
+  FRACTAL_DECONV_SP_STRIDE_TRANS,
+  NC1HWC0_C04,    // NC1HWC0, C0 is 4
+  FRACTAL_Z_C04,  // FRACZ, C0 is 4
+  CHWN,
+  FRACTAL_DECONV_SP_STRIDE8_TRANS,
+  HWCN,
+  NC1KHKWHWC0,  // KH,KW kernel h& kernel w maxpooling max output format
+  BN_WEIGHT,
+  FILTER_HWCK,  // filter input tensor format
+  LOOKUP_LOOKUPS,
+  LOOKUP_KEYS,
+  LOOKUP_VALUE,
+  LOOKUP_OUTPUT,
+  LOOKUP_HITS,
+  C1HWNCoC0,
+  MD,
+  FRACTAL_ZZ,
+  DHWCN,  // 3D filter input tensor format
+  NDC1HWC0,
+  FRACTAL_Z_3D,
+  CN,
+  DHWNC,
+  FRACTAL_Z_3D_TRANSPOSE,  // 3D filter(transpose) input tensor format
+  FRACTAL_ZN_LSTM,
+  FRACTAL_Z_G,
+  ND_RNN_BIAS,
+  FRACTAL_ZN_RNN,
+  NYUV,
+  NYUV_A,
+  NCL,
+  NUM_OF_FORMAT
 };
 
-inline std::string FormatEnumToString(mindspore::Format format) {
+inline const std::vector<std::string> &GetFormatNames() {
   static std::vector<std::string> names = {
-    "NCHW", "NHWC", "NHWC4", "HWKC", "HWCK",   "KCHW",          "CKHW",  "KHWC", "CHWK",
-    "HW",   "HW4",  "NC",    "NC4",  "NC4HW4", "NUM_OF_FORMAT", "NCDHW", "NWC",  "NCW",
+    "NCHW",
+    "NHWC",
+    "NHWC4",
+    "HWKC",
+    "HWCK",
+    "KCHW",
+    "CKHW",
+    "KHWC",
+    "CHWK",
+    "HW",
+    "HW4",
+    "NC",
+    "NC4",
+    "NC4HW4",
+    "NCDHW",
+    "NWC",
+    "NCW",
+    "NDHWC",
+    "NC8HW8",
+    "FRACTAL_NZ",
+    "ND",
+    "NC1HWC0",
+    "FRACTAL_Z",
+    "NC1C0HWPAD",
+    "NHWC1C0",
+    "FSR_NCHW",
+    "FRACTAL_DECONV",
+    "C1HWNC0",
+    "FRACTAL_DECONV_TRANSPOSE",
+    "FRACTAL_DECONV_SP_STRIDE_TRANS",
+    "NC1HWC0_C04",
+    "FRACTAL_Z_C04",
+    "CHWN",
+    "FRACTAL_DECONV_SP_STRIDE8_TRANS",
+    "HWCN",
+    "NC1KHKWHWC0",
+    "BN_WEIGHT",
+    "FILTER_HWCK",
+    "LOOKUP_LOOKUPS",
+    "LOOKUP_KEYS",
+    "LOOKUP_VALUE",
+    "LOOKUP_OUTPUT",
+    "LOOKUP_HITS",
+    "C1HWNCoC0",
+    "MD",
+    "FRACTAL_ZZ",
+    "DHWCN",
+    "NDC1HWC0",
+    "FRACTAL_Z_3D",
+    "CN",
+    "DHWNC",
+    "FRACTAL_Z_3D_TRANSPOSE",
+    "FRACTAL_ZN_LSTM",
+    "FRACTAL_Z_G",
+    "ND_RNN_BIAS",
+    "FRACTAL_ZN_RNN",
+    "NYUV",
+    "NYUV_A",
+    "NCL",
   };
+  return names;
+}
+
+inline std::string FormatEnumToString(mindspore::Format format) {
+  const auto &names = GetFormatNames();
   if (format == mindspore::Format::DEFAULT_FORMAT) {
     return "DefaultFormat";
   }
-  if (format < mindspore::NCHW || format > mindspore::NCW) {
+  if (format < mindspore::NCHW || format >= mindspore::NUM_OF_FORMAT) {
     return "";
   }
   return names[format];

mindspore/include/mindapi/base/types.h

@@ -71,6 +71,11 @@ enum ActivationType : int64_t {
   GELU = 19,
   GLU = 20,
   UNKNOWN = 21,
+  FASTGELU = 22,
+  SILU = 23,
+  GEGLU = 24,
+  SWIGLU = 25,
+  REGLU = 26,
 };
 
 enum ReduceMode : int64_t {
@@ -105,6 +110,7 @@ enum PadMode : int64_t {
   PAD = 0,
   SAME = 1,
   VALID = 2,
+  FULL = 3,
 };
 
 enum class LshProjectionType : int64_t {
@@ -124,5 +130,11 @@ enum PoolMode : int64_t {
   MAX_POOLING = 0,
   MEAN_POOLING = 1,
 };
+
+enum NormMode : int64_t { BACKWARD = 0, FORWARD = 1, ORTHO = 2 };
+
+// float is a float64 in python. But for some historical reason, python float is converted to float32 in
+using pyfloat = float;
+using pyint = int32_t;
 }  // namespace mindspore
 #endif  // MINDSPORE_CORE_MINDAPI_BASE_TYPES_H_