mindspore 2.3.0__cp310-cp310-win_amd64.whl

mindspore/include/c_api/ms/tensor.h

@@ -0,0 +1,161 @@
+/**
+ * Copyright 2022 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_CCSRC_C_API_INCLUDE_FUNC_TENSOR_H_
+#define MINDSPORE_CCSRC_C_API_INCLUDE_FUNC_TENSOR_H_
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include "include/c_api/ms/base/macros.h"
+#include "include/c_api/ms/base/status.h"
+#include "include/c_api/ms/base/types.h"
+#include "include/c_api/ms/base/handle_types.h"
+#include "include/c_api/ms/context.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// \brief Create a tensor with input data buffer.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] data The input data to be copied into tensor.
+/// \param[in] type [TypeId] Data type of the tensor.
+/// \param[in] shape The shape arary of the tensor.
+/// \param[in] shape_size The size of shape array, i.e., the rank of the tensor.
+/// \param[in] data_len The length of data in bytes.
+///
+/// \return The pointer of the created tensor instance.
+MIND_C_API TensorHandle MSNewTensor(ResMgrHandle res_mgr, void *data, DataTypeC type, const int64_t shape[],
+                                    size_t shape_size, size_t data_len);
+
+/// \brief Create a tensor with path to a space-sperated txt file.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] type [TypeId] Data type of the tensor.
+/// \param[in] shape The shape arary of the tensor.
+/// \param[in] shape_size The size of shape array, i.e., the rank of the tensor.
+/// \param[in] path path to the file.
+///
+/// \return The pointer of the created tensor instance.
+MIND_C_API TensorHandle MSNewTensorFromFile(ResMgrHandle res_mgr, DataTypeC type, const int64_t shape[],
+                                            size_t shape_size, const char *path);
+
+/// \brief Create a tensor with input data buffer and given source data type.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] shape The shape arary of the tensor.
+/// \param[in] shape_size The size of shape array, i.e., the rank of the tensor.
+/// \param[in] data The input data to be copied into tensor.
+/// \param[in] tensor_type [TypeId] Data type of the tensor.
+/// \param[in] src_type [TypeId] The source data type.
+///
+/// \return The pointer of the created tensor instance.
+MIND_C_API TensorHandle MSNewTensorWithSrcType(ResMgrHandle res_mgr, void *data, const int64_t shape[],
+                                               size_t shape_size, DataTypeC tensor_type, DataTypeC src_type);
+
+/// \brief Create a tensor with float32 scalar value.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] value The input scalar value.
+///
+/// \return The pointer of the created tensor instance.
+MIND_C_API TensorHandle MSNewTensorScalarFloat32(ResMgrHandle res_mgr, float value);
+
+/// \brief Create a tensor with int32 scalar value.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] value The input scalar value.
+///
+/// \return The pointer of the created tensor instance.
+MIND_C_API TensorHandle MSNewTensorScalarInt32(ResMgrHandle res_mgr, int value);
+
+/// \brief Get the raw pointer of tensor data.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+///
+/// \return The pointer to the tensor data
+MIND_C_API void *MSTensorGetData(ResMgrHandle res_mgr, ConstTensorHandle tensor);
+
+/// \brief Set tensor data type.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+/// \param[in] type The data type to be set.
+///
+/// \return Error code that indicate whether the functions executed successfully.
+MIND_C_API STATUS MSTensorSetDataType(ResMgrHandle res_mgr, TensorHandle tensor, DataTypeC type);
+
+/// \brief Get tensor data type.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+///
+/// \return The data type of tensor.
+MIND_C_API DataTypeC MSTensorGetDataType(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
+
+/// \brief Get the byte size of tensor data.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+/// \param[in] error Records error code that indicate whether the functions executed successfully.
+///
+/// \return The byte size of tensor data.
+MIND_C_API size_t MSTensorGetDataSize(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
+
+/// \brief Get the element number of tensor array.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+/// \param[in] error Records error code that indicate whether the functions executed successfully.
+///
+/// \return The element number of tensor array.
+MIND_C_API size_t MSTensorGetElementNum(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
+
+/// \brief Get the dimension of tensor.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+/// \param[in] error Records error code that indicate whether the functions executed successfully.
+///
+/// \return The dimension of tensor.
+MIND_C_API size_t MSTensorGetDimension(ResMgrHandle res_mgr, ConstTensorHandle tensor, STATUS *error);
+
+/// \brief Set the shape of tensor array.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+/// \param[in] shape The shape array.
+/// \param[in] dim The the dimension of tensor, i.e., size of shape array.
+///
+/// \return Error code indicates whether the function executed successfully.
+MIND_C_API STATUS MSTensorSetShape(ResMgrHandle res_mgr, TensorHandle tensor, const int64_t shape[], size_t dim);
+
+/// \brief Get the shape of tensor array.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] tensor The pointer of the tensor instance.
+/// \param[in] shape The shape array.
+/// \param[in] dim The the dimension of tensor, i.e., size of shape array.
+///
+/// \return Error code indicates whether the function executed successfully.
+MIND_C_API STATUS MSTensorGetShape(ResMgrHandle res_mgr, ConstTensorHandle tensor, int64_t shape[], size_t dim);
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_CCSRC_C_API_INCLUDE_FUNC_TENSOR_H_

mindspore/include/c_api/ms/value.h

@@ -0,0 +1,84 @@
+/**
+ * Copyright 2022 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_CCSRC_C_API_INCLUDE_VALUE_H_
+#define MINDSPORE_CCSRC_C_API_INCLUDE_VALUE_H_
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include "include/c_api/ms/base/macros.h"
+#include "include/c_api/ms/base/handle_types.h"
+#include "include/c_api/ms/base/types.h"
+#include "include/c_api/ms/context.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// \brief Create new Int64 scalar value.
+///
+/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
+/// \param[in] v Given value.
+///
+/// \return Value handle.
+MIND_C_API ValueHandle MSNewValueInt64(ResMgrHandle res_mgr, const int64_t v);
+
+/// \brief Create new flaot32 scalar value.
+///
+/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
+/// \param[in] v Given value.
+///
+/// \return Value handle.
+MIND_C_API ValueHandle MSNewValueFloat32(ResMgrHandle res_mgr, const float v);
+
+/// \brief Create new Bool scalar value.
+///
+/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
+/// \param[in] v Given value.
+///
+/// \return Value handle.
+MIND_C_API ValueHandle MSNewValueBool(ResMgrHandle res_mgr, const bool v);
+
+/// \brief Create new value of DataType.
+///
+/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
+/// \param[in] type Given data type.
+///
+/// \return Value handle.
+MIND_C_API ValueHandle MSNewValueType(ResMgrHandle res_mgr, DataTypeC type);
+
+/// \brief Create new vector of Strings Value.
+///
+/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
+/// \param[in] strs Given value.
+/// \param[in] vec_len Length of the string vector.
+///
+/// \return Value handle.
+MIND_C_API ValueHandle MSNewValueStrings(ResMgrHandle res_mgr, const char *strs[], size_t vec_len);
+
+/// \brief Create new Value with array.
+///
+/// \param[in] res_mgr Resource Handle that manages the nodes of the funcGraph.
+/// \param[in] value Given array.
+/// \param[in] vec_size Given array size.
+/// \param[in] data_type Datatype of the array.
+///
+/// \return Value handle
+MIND_C_API ValueHandle MSNewValueArray(ResMgrHandle res_mgr, void *value, size_t vec_size, DataTypeC data_type);
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_CCSRC_C_API_INCLUDE_VALUE_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

mindspore/include/c_api/types_c.h

@@ -0,0 +1,67 @@
+/**
+ * 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_TYPES_C_H
+#define MINDSPORE_INCLUDE_C_API_TYPES_C_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef MS_API
+#ifdef _WIN32
+#define MS_API __declspec(dllexport)
+#else
+#define MS_API __attribute__((visibility("default")))
+#endif
+#endif
+
+typedef enum MSModelType {
+  kMSModelTypeMindIR = 0,
+  // insert new data type here
+  kMSModelTypeInvalid = 0xFFFFFFFF
+} MSModelType;
+
+typedef enum MSDeviceType {
+  kMSDeviceTypeCPU = 0,
+  kMSDeviceTypeGPU,
+  kMSDeviceTypeKirinNPU,
+  // add new type here
+  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
+#endif  // MINDSPORE_INCLUDE_C_API_TYPES_C_H