mindspore 2.4.0__cp311-cp311-macosx_11_0_arm64.whl

mindspore/include/c_api/data_type_c.h

@@ -0,0 +1,52 @@
+/**
+ * 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 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_C_API_DATA_TYPE_C_H
+#define MINDSPORE_INCLUDE_C_API_DATA_TYPE_C_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum MSDataType {
+  kMSDataTypeUnknown = 0,
+  kMSDataTypeObjectTypeString = 12,
+  kMSDataTypeObjectTypeList = 13,
+  kMSDataTypeObjectTypeTuple = 14,
+  kMSDataTypeObjectTypeTensor = 17,
+  kMSDataTypeNumberTypeBegin = 29,
+  kMSDataTypeNumberTypeBool = 30,
+  kMSDataTypeNumberTypeInt8 = 32,
+  kMSDataTypeNumberTypeInt16 = 33,
+  kMSDataTypeNumberTypeInt32 = 34,
+  kMSDataTypeNumberTypeInt64 = 35,
+  kMSDataTypeNumberTypeUInt8 = 37,
+  kMSDataTypeNumberTypeUInt16 = 38,
+  kMSDataTypeNumberTypeUInt32 = 39,
+  kMSDataTypeNumberTypeUInt64 = 40,
+  kMSDataTypeNumberTypeFloat16 = 42,
+  kMSDataTypeNumberTypeFloat32 = 43,
+  kMSDataTypeNumberTypeFloat64 = 44,
+  kMSDataTypeNumberTypeEnd = 46,
+  // add new enum here
+  kMSDataTypeInvalid = INT32_MAX,
+} MSDataType;
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_INCLUDE_C_API_DATA_TYPE_C_H

mindspore/include/c_api/format_c.h

@@ -0,0 +1,46 @@
+/**
+ * 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 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_C_API_FORMAT_C_H
+#define MINDSPORE_INCLUDE_C_API_FORMAT_C_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum MSFormat {
+  kMSFormatNCHW = 0,
+  kMSFormatNHWC = 1,
+  kMSFormatNHWC4 = 2,
+  kMSFormatHWKC = 3,
+  kMSFormatHWCK = 4,
+  kMSFormatKCHW = 5,
+  kMSFormatCKHW = 6,
+  kMSFormatKHWC = 7,
+  kMSFormatCHWK = 8,
+  kMSFormatHW = 9,
+  kMSFormatHW4 = 10,
+  kMSFormatNC = 11,
+  kMSFormatNC4 = 12,
+  kMSFormatNC4HW4 = 13,
+  kMSFormatNCDHW = 15,
+  kMSFormatNWC = 16,
+  kMSFormatNCW = 17
+} MSFormat;
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_INCLUDE_C_API_FORMAT_C_H

mindspore/include/c_api/model_c.h

@@ -0,0 +1,347 @@
+/**
+ * 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 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_C_API_MODEL_C_H
+#define MINDSPORE_INCLUDE_C_API_MODEL_C_H
+
+#include "include/c_api/tensor_c.h"
+#include "include/c_api/context_c.h"
+#include "include/c_api/status_c.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *MSModelHandle;
+
+typedef void *MSTrainCfgHandle;
+
+typedef struct MSTensorHandleArray {
+  size_t handle_num;
+  MSTensorHandle *handle_list;
+} MSTensorHandleArray;
+
+#define MS_MAX_SHAPE_NUM 32
+typedef struct MSShapeInfo {
+  size_t shape_num;
+  int64_t shape[MS_MAX_SHAPE_NUM];
+} MSShapeInfo;
+
+typedef struct MSCallBackParamC {
+  char *node_name;
+  char *node_type;
+} MSCallBackParamC;
+
+typedef bool (*MSKernelCallBackC)(const MSTensorHandleArray inputs, const MSTensorHandleArray outputs,
+                                  const MSCallBackParamC kernel_Info);
+
+/// \brief Create a model object.
+///
+/// \return Model object handle.
+MS_API MSModelHandle MSModelCreate();
+
+/// \brief Destroy the model object.
+///
+/// \param[in] model Model object handle address.
+MS_API void MSModelDestroy(MSModelHandle *model);
+
+/// \brief Set workspace for the model object. Only valid for Iot.
+///
+/// \param[in] model Model object handle.
+/// \param[in] workspace Define the workspace address.
+/// \param[in] workspace_size Define the workspace size.
+MS_API void MSModelSetWorkspace(MSModelHandle model, void *workspace, size_t workspace_size);
+
+/// \brief Calculate the workspace size required for model inference. Only valid for Iot.
+///
+/// \param[in] model Model object handle.
+MS_API size_t MSModelCalcWorkspaceSize(MSModelHandle model);
+
+/// \brief Build the model from model file buffer so that it can run on a device.
+///
+/// \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.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelBuild(MSModelHandle model, const void *model_data, size_t data_size, MSModelType model_type,
+                             const MSContextHandle model_context);
+
+/// \brief Load and build the model from model path so that it can run on a device.
+///
+/// \param[in] model Model object handle.
+/// \param[in] model_path Define the model file path.
+/// \param[in] model_type Define The type of model file.
+/// \param[in] model_context Define the context used to store options during execution.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelBuildFromFile(MSModelHandle model, const char *model_path, MSModelType model_type,
+                                     const MSContextHandle model_context);
+
+/// \brief Resize the shapes of inputs.
+///
+/// \param[in] model Model object handle.
+/// \param[in] inputs The array that includes all input tensor handles.
+/// \param[in] shape_infos Defines the new shapes of inputs, should be consistent with inputs.
+/// \param[in] shape_info_num The num of shape_infos.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelResize(MSModelHandle model, const MSTensorHandleArray inputs, MSShapeInfo *shape_infos,
+                              size_t shape_info_num);
+
+/// \brief Inference model.
+///
+/// \param[in] model Model object handle.
+/// \param[in] inputs The array that includes all input tensor handles.
+/// \param[out] outputs The array that includes all output tensor handles.
+/// \param[in] before CallBack before predict.
+/// \param[in] after CallBack after predict.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelPredict(MSModelHandle model, const MSTensorHandleArray inputs, MSTensorHandleArray *outputs,
+                               const MSKernelCallBackC before, const MSKernelCallBackC after);
+
+/// \brief Run model by step. Only valid for Iot.
+///
+/// \param[in] model Model object handle.
+/// \param[in] before CallBack before RunStep.
+/// \param[in] after CallBack after RunStep.
+///
+/// \return MSStatus.
+MS_API MSStatus MSModelRunStep(MSModelHandle model, const MSKernelCallBackC before, const MSKernelCallBackC after);
+
+/// \brief Set the model running mode. Only valid for Iot.
+///
+/// \param[in] model Model object handle.
+/// \param[in] train True means model runs in Train Mode, otherwise Eval Mode.
+///
+/// \return Status of operation.
+MS_API MSStatus MSModelSetTrainMode(const MSModelHandle model, bool train);
+
+/// \brief Export the weights of model to the binary file. Only valid for Iot.
+///
+/// \param[in] model Model object handle.
+/// \param[in] export_path Define the export weight file path.
+///
+/// \return Status of operation.
+MS_API MSStatus MSModelExportWeight(const MSModelHandle model, const char *export_path);
+
+/// \brief Obtain all input tensor handles of the model.
+///
+/// \param[in] model Model object handle.
+///
+/// \return The array that includes all input tensor handles.
+MS_API MSTensorHandleArray MSModelGetInputs(const MSModelHandle model);
+
+/// \brief Obtain all output tensor handles of the model.
+///
+/// \param[in] model Model object handle.
+///
+/// \return The array that includes all output tensor handles.
+MS_API MSTensorHandleArray MSModelGetOutputs(const MSModelHandle model);
+
+/// \brief Obtain the input tensor handle of the model by name.
+///
+/// \param[in] model Model object handle.
+/// \param[in] tensor_name The name of tensor.
+///
+/// \return The input tensor handle with the given name, if the name is not found, an NULL is returned.
+MS_API MSTensorHandle MSModelGetInputByTensorName(const MSModelHandle model, const char *tensor_name);
+
+/// \brief Obtain the output tensor handle of the model by name.
+///
+/// \param[in] model Model object handle.
+/// \param[in] tensor_name The name of tensor.
+///
+/// \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
+#endif  // MINDSPORE_INCLUDE_C_API_MODEL_C_H

mindspore/include/c_api/status_c.h

@@ -0,0 +1,79 @@
+/**
+ * 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 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_C_API_STATUS_C_H
+#define MINDSPORE_INCLUDE_C_API_STATUS_C_H
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum MSCompCode {
+  kMSCompCodeCore = 0x00000000u,
+  kMSCompCodeMD = 0x10000000u,
+  kMSCompCodeME = 0x20000000u,
+  kMSCompCodeMC = 0x30000000u,
+  kMSCompCodeLite = 0xF0000000u,
+};
+
+typedef enum MSStatus {
+  kMSStatusSuccess = 0,
+  // Core
+  kMSStatusCoreFailed = kMSCompCodeCore | 0x1,
+
+  // Lite  // Common error code, range: [-1, -100)
+  kMSStatusLiteError = kMSCompCodeLite | (0x0FFFFFFF & -1),            /**< Common error code. */
+  kMSStatusLiteNullptr = kMSCompCodeLite | (0x0FFFFFFF & -2),          /**< NULL pointer returned.*/
+  kMSStatusLiteParamInvalid = kMSCompCodeLite | (0x0FFFFFFF & -3),     /**< Invalid parameter.*/
+  kMSStatusLiteNoChange = kMSCompCodeLite | (0x0FFFFFFF & -4),         /**< No change. */
+  kMSStatusLiteSuccessExit = kMSCompCodeLite | (0x0FFFFFFF & -5),      /**< No error but exit. */
+  kMSStatusLiteMemoryFailed = kMSCompCodeLite | (0x0FFFFFFF & -6),     /**< Fail to create memory. */
+  kMSStatusLiteNotSupport = kMSCompCodeLite | (0x0FFFFFFF & -7),       /**< Fail to support. */
+  kMSStatusLiteThreadPoolError = kMSCompCodeLite | (0x0FFFFFFF & -8),  /**< Error occur in thread pool. */
+  kMSStatusLiteUninitializedObj = kMSCompCodeLite | (0x0FFFFFFF & -9), /**< Object is not initialized. */
+  kMSStatusLiteFileError = kMSCompCodeLite | (0x0FFFFFFF & -10),       /**< Invalid file. */
+  kMSStatusLiteServiceDeny = kMSCompCodeLite | (0x0FFFFFFF & -11),     /**< Denial of service. */
+  kMSStatusLiteModelRebuild = kMSCompCodeLite | (0x0FFFFFFF & -12),    /**< Model has been built. */
+
+  // Executor error code, range: [-100,-200)
+  kMSStatusLiteOutOfTensorRange = kMSCompCodeLite | (0x0FFFFFFF & -100), /**< Failed to check range. */
+  kMSStatusLiteInputTensorError = kMSCompCodeLite | (0x0FFFFFFF & -101), /**< Failed to check input tensor. */
+  kMSStatusLiteReentrantError = kMSCompCodeLite | (0x0FFFFFFF & -102),   /**< Exist executor running. */
+
+  // Graph error code, range: [-200,-300)
+  kMSStatusLiteGraphFileError = kMSCompCodeLite | (0x0FFFFFFF & -200), /**< Failed to verify graph file. */
+
+  // Node error code, range: [-300,-400)
+  kMSStatusLiteNotFindOp = kMSCompCodeLite | (0x0FFFFFFF & -300),        /**< Failed to find operator. */
+  kMSStatusLiteInvalidOpName = kMSCompCodeLite | (0x0FFFFFFF & -301),    /**< Invalid operator name. */
+  kMSStatusLiteInvalidOpAttr = kMSCompCodeLite | (0x0FFFFFFF & -302),    /**< Invalid operator attr. */
+  kMSStatusLiteOpExecuteFailure = kMSCompCodeLite | (0x0FFFFFFF & -303), /**< Failed to execution operator. */
+
+  // Tensor error code, range: [-400,-500)
+  kMSStatusLiteFormatError = kMSCompCodeLite | (0x0FFFFFFF & -400), /**< Failed to checking tensor format. */
+
+  // InferShape error code, range: [-500,-600)
+  kMSStatusLiteInferError = kMSCompCodeLite | (0x0FFFFFFF & -500),   /**< Failed to infer shape. */
+  kMSStatusLiteInferInvalid = kMSCompCodeLite | (0x0FFFFFFF & -501), /**< Invalid infer shape before runtime. */
+
+  // User input param error code, range: [-600, 700)
+  kMSStatusLiteInputParamInvalid = kMSCompCodeLite | (0x0FFFFFFF & -600), /**< Invalid input param by user. */
+} MSStatus;
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_INCLUDE_C_API_STATUS_C_H

mindspore/include/c_api/tensor_c.h

@@ -0,0 +1,146 @@
+/**
+ * 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 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_C_API_TENSOE_C_H
+#define MINDSPORE_INCLUDE_C_API_TENSOE_C_H
+
+#include <stddef.h>
+#include "include/c_api/types_c.h"
+#include "include/c_api/data_type_c.h"
+#include "include/c_api/format_c.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void *MSTensorHandle;
+
+/// \brief Create a tensor object.
+///
+/// \param[in] name The name of the tensor.
+/// \param[in] type The data type of the tensor.
+/// \param[in] shape The shape of the tensor.
+/// \param[in] shape_num The num of the shape.
+/// \param[in] data The data pointer that points to allocated memory.
+/// \param[in] data_len The length of the memory, in bytes.
+///
+/// \return Tensor object handle.
+MS_API MSTensorHandle MSTensorCreate(const char *name, MSDataType type, const int64_t *shape, size_t shape_num,
+                                     const void *data, size_t data_len);
+
+/// \brief Destroy the tensor object.
+///
+/// \param[in] tensor Tensor object handle address.
+MS_API void MSTensorDestroy(MSTensorHandle *tensor);
+
+/// \brief Obtain a deep copy of the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return Tensor object handle.
+MS_API MSTensorHandle MSTensorClone(MSTensorHandle tensor);
+
+/// \brief Set the name for the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+/// \param[in] name The name of the tensor.
+MS_API void MSTensorSetName(MSTensorHandle tensor, const char *name);
+
+/// \brief Obtain the name of the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return The name of the tensor.
+MS_API const char *MSTensorGetName(const MSTensorHandle tensor);
+
+/// \brief Set the data type for the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+/// \param[in] type The data type of the tensor.
+MS_API void MSTensorSetDataType(MSTensorHandle tensor, MSDataType type);
+
+/// \brief Obtain the data type of the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return The date type of the tensor.
+MS_API MSDataType MSTensorGetDataType(const MSTensorHandle tensor);
+
+/// \brief Set the shape for the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+/// \param[in] shape The shape array.
+/// \param[in] shape_num Dimension of shape.
+MS_API void MSTensorSetShape(MSTensorHandle tensor, const int64_t *shape, size_t shape_num);
+
+/// \brief Obtain the shape of the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+/// \param[out] shape_num Dimension of shape.
+///
+/// \return The shape array of the tensor.
+MS_API const int64_t *MSTensorGetShape(const MSTensorHandle tensor, size_t *shape_num);
+
+/// \brief Set the format for the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+/// \param[in] format The format of the tensor.
+MS_API void MSTensorSetFormat(MSTensorHandle tensor, MSFormat format);
+
+/// \brief Obtain the format of the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return The format of the tensor.
+MS_API MSFormat MSTensorGetFormat(const MSTensorHandle tensor);
+
+/// \brief Obtain the data for the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+/// \param[in] data A pointer to the data of the tensor.
+MS_API void MSTensorSetData(MSTensorHandle tensor, void *data);
+
+/// \brief Obtain the data pointer of the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return The data pointer of the tensor.
+MS_API const void *MSTensorGetData(const MSTensorHandle tensor);
+
+/// \brief Obtain the mutable data pointer of the tensor. If the internal data is empty, it will allocate memory.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return The data pointer of the tensor.
+MS_API void *MSTensorGetMutableData(const MSTensorHandle tensor);
+
+/// \brief Obtain the element number of the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return The element number of the tensor.
+MS_API int64_t MSTensorGetElementNum(const MSTensorHandle tensor);
+
+/// \brief Obtain the data size fo the tensor.
+///
+/// \param[in] tensor Tensor object handle.
+///
+/// \return The data size of the tensor.
+MS_API size_t MSTensorGetDataSize(const MSTensorHandle tensor);
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_INCLUDE_C_API_TENSOE_C_H