mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/include/api/context.h

@@ -1,5 +1,5 @@
 /**
- * Copyright 2020 Huawei Technologies Co., Ltd
+ * Copyright 2020-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.
@@ -66,6 +66,16 @@ class MS_API Context {
   /// \return The current thread number setting.
   int32_t GetThreadNum() const;
 
+  /// \brief Set the communication group info file path.
+  ///
+  /// \param[in] group_info_file communication group info file for distributed inference.
+  void SetGroupInfoFile(std::string group_info_file);
+
+  /// \brief Get the communication group info file path.
+  ///
+  /// \return The communication group info file path setting.
+  std::string GetGroupInfoFile() const;
+
   /// \brief Set the parallel number of operators at runtime.
   ///
   /// \param[in] parallel_num the parallel number of operators at runtime.
@@ -393,6 +403,16 @@ class MS_API AscendDeviceInfo : public DeviceInfoContext {
   /// \return The device id.
   uint32_t GetDeviceID() const;
 
+  /// \brief Set the distribution rank id.
+  ///
+  /// \param[in] rank_id The rank id.
+  void SetRankID(uint32_t rank_id);
+
+  /// \brief Get the distribution rank id.
+  ///
+  /// \return The rank id.
+  uint32_t GetRankID() const;
+
   /// \brief Set AIPP configuration file path.
   ///
   /// \param[in] cfg_path AIPP configuration file path.

mindspore/include/api/data_type.h

@@ -38,7 +38,8 @@ enum class DataType : int {
   kNumberTypeFloat16 = 42,
   kNumberTypeFloat32 = 43,
   kNumberTypeFloat64 = 44,
-  kNumberTypeEnd = 46,
+  kNumberTypeBFloat16 = 46,
+  kNumberTypeEnd = 53,
   // add new enum here
   kInvalidType = INT32_MAX,
 };

mindspore/include/api/graph.h

@@ -24,38 +24,23 @@
 #include "include/api/types.h"
 
 namespace mindspore {
-class NetData;
-class Net;
-
 class MS_API Graph {
  public:
   class GraphData;
-  enum Type : uint32_t {
-    kExpressionGraph = 0,  ///< graph as expression - can auto grad
-    kExecutableGraph = 1,  ///< graph is loaded as is
-    kUnknownTypeGraph = 0xffffffff
-  };
   Graph();
   explicit Graph(const std::shared_ptr<GraphData> &graph_data);
   explicit Graph(std::shared_ptr<GraphData> &&graph_data);
   explicit Graph(std::nullptr_t);
   ~Graph();
-  explicit Graph(Type executable);
-  explicit Graph(Net *net);
 
   enum ModelType ModelType() const;
   bool operator==(std::nullptr_t) const;
   bool operator!=(std::nullptr_t) const;
-  bool IsExecutable() { return graph_type_ == kExecutableGraph; }
 
  private:
   friend class GraphCell;
   friend class ModelImpl;
-  friend class NetImpl;
-  friend class Model;
   std::shared_ptr<GraphData> graph_data_;
-  std::shared_ptr<NetData> net_data_;
-  Type graph_type_ = kExecutableGraph;
 };
 }  // namespace mindspore
 #endif  // MINDSPORE_INCLUDE_API_GRAPH_H

mindspore/include/api/kernel.h

@@ -35,6 +35,8 @@ class MS_API Kernel : public IKernel<schema::Primitive> {
     Initialize();
   }
   virtual ~Kernel() = default;
+
+  int InferShape() override;
   /// \brief obtain kernel's type.
   ///
   /// \return kernel's type.

mindspore/include/api/kernel_api.h

@@ -21,25 +21,29 @@
 #include <utility>
 #include <map>
 #include "include/api/types.h"
+#include "include/api/status.h"
 namespace mindspore {
 class Context;
 namespace kernel {
 /// \brief The Kernel class is used to define a MindSpore Kernel.
-template <typename Primitive>
-class MS_API IKernel {
+class MS_API MSKernel {
  public:
-  IKernel() = default;
+  MSKernel() = default;
   /// \brief Constructor.
   ///
   /// \param[in] inputs define the input tensors for kernel.
   /// \param[in] outputs define the output tensors for kernel.
   /// \param[in] primitive define the primitive of kernel.
   /// \param[in] ctx define the context for kernel.
-  IKernel(const std::vector<mindspore::MSTensor> &inputs, const std::vector<mindspore::MSTensor> &outputs,
-          const Primitive *primitive, const mindspore::Context *ctx)
-      : context_(ctx), inputs_(std::move(inputs)), outputs_(std::move(outputs)), primitive_(primitive) {}
+  MSKernel(std::vector<mindspore::MSTensor> inputs, std::vector<mindspore::MSTensor> outputs,
+           const mindspore::Context *ctx)
+      : context_(ctx), inputs_(std::move(inputs)), outputs_(std::move(outputs)) {}
   /// \brief Destructor.
-  virtual ~IKernel() = default;
+  virtual ~MSKernel() = default;
+  /// \brief infer shape, datatype and format for output tensor of kernel.
+  ///
+  /// \return result code.
+  virtual int InferShape() { return kLiteError; }
   /// \brief prepare for executing kernel.
   ///
   /// \return result code.
@@ -81,7 +85,7 @@ class MS_API IKernel {
   /// \brief obtain kernel's name.
   ///
   /// \return kernel's name.
-  std::string name() const { return this->name_; }
+  virtual std::string name() const { return this->name_; }
   /// \brief set kernel's name.
   ///
   /// \param[in] name define the kernel's name.
@@ -90,9 +94,6 @@ class MS_API IKernel {
   ///
   /// \return kernel's context.
   const mindspore::Context *context() const { return this->context_; }
-  ///
-  /// \return the primitive of kernel generated by flatbuffers.
-  const Primitive *primitive() const { return this->primitive_; }
 
   /// \brief get kernel's attribute.
   ///
@@ -134,10 +135,34 @@ class MS_API IKernel {
   const mindspore::Context *context_ = nullptr;
   std::vector<mindspore::MSTensor> inputs_;
   std::vector<mindspore::MSTensor> outputs_;
-  const Primitive *primitive_ = nullptr;
   std::map<std::string, std::string> attrs_;
   const std::map<std::string, std::map<std::string, std::string>> *config_ = nullptr;
 };
+
+/// \brief The Kernel class is used to define a MindSpore Kernel with specific primitive.
+template <typename Primitive>
+class MS_API IKernel : public MSKernel {
+ public:
+  IKernel() = default;
+  /// \brief Constructor.
+  ///
+  /// \param[in] inputs define the input tensors for kernel.
+  /// \param[in] outputs define the output tensors for kernel.
+  /// \param[in] primitive define the primitive of kernel.
+  /// \param[in] ctx define the context for kernel.
+  IKernel(const std::vector<mindspore::MSTensor> &inputs, const std::vector<mindspore::MSTensor> &outputs,
+          const Primitive *primitive, const mindspore::Context *ctx)
+      : MSKernel(inputs, outputs, ctx), primitive_(primitive) {}
+  /// \brief Destructor.
+  ~IKernel() override = default;
+  /// \brief get the primitive of kernel.
+  ///
+  /// \return the primitive of kernel generated by flatbuffers.
+  const Primitive *primitive() const { return this->primitive_; }
+
+ protected:
+  const Primitive *primitive_ = nullptr;
+};
 }  // namespace kernel
 }  // namespace mindspore
 #endif  // MINDSPORE_INCLUDE_API_KERNEL_API_H

mindspore/include/api/model.h

@@ -33,9 +33,6 @@
 namespace mindspore {
 class ModelImpl;
 class Metrics;
-class Net;
-class Node;
-class Expr;
 
 namespace dataset {
 class Dataset;
@@ -45,44 +42,43 @@ class MS_API Model {
  public:
   Model();
   ~Model();
-  Model(const Model &) = delete;
-  void operator=(const Model &) = delete;
 
   /// \brief Build a model from model buffer so that it can run on a device.
   ///
   /// \param[in] model_data Define the buffer read from a model file.
   /// \param[in] data_size Define bytes number of model buffer.
-  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kOM. Only
-  /// ModelType::kMindIR is valid for Lite.
-  /// \param[in] model_context Define the context used to store options during execution.
+  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kMindIR_Lite. Only
+  /// ModelType::kMindIR_Lite is valid for Device-side Inference. Cloud-side Inference supports options
+  /// ModelType::kMindIR and ModelType::kMindIR_Lite, but option odelType::kMindIR_Lite will be removed in future
+  /// iterations. \param[in] model_context Define the context used to store options during execution.
   ///
-  /// \return Status.
+  /// \return Status. kSuccess: build success, kLiteModelRebuild: build model repeatedly, Other: other types of errors.
   Status Build(const void *model_data, size_t data_size, ModelType model_type,
                const std::shared_ptr<Context> &model_context = nullptr);
 
   /// \brief Load and build a model from model buffer so that it can run on a device.
   ///
   /// \param[in] model_path Define the model path.
-  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kOM. Only
-  /// ModelType::kMindIR is valid for Lite.
-  /// \param[in] model_context Define the context used to store options during execution.
+  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kMindIR_Lite. Only
+  /// ModelType::kMindIR_Lite is valid for Device-side Inference. Cloud-side Inference supports options
+  /// ModelType::kMindIR and ModelType::kMindIR_Lite, but option odelType::kMindIR_Lite will be removed in future
+  /// iterations. \param[in] model_context Define the context used to store options during execution.
   ///
-  /// \return Status.
+  /// \return Status. kSuccess: build success, kLiteModelRebuild: build model repeatedly, Other: other types of errors.
   inline Status Build(const std::string &model_path, ModelType model_type,
                       const std::shared_ptr<Context> &model_context = nullptr);
-
   /// \brief Build a model from model buffer so that it can run on a device.
   ///
   /// \param[in] model_data Define the buffer read from a model file.
   /// \param[in] data_size Define bytes number of model buffer.
-  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kOM. Only
-  /// ModelType::kMindIR is valid for Lite.
-  /// \param[in] model_context Define the context used to store options during execution.
-  /// \param[in] dec_key Define the key used to decrypt the ciphertext model. The key length is 16.
-  /// \param[in] dec_mode Define the decryption mode. Options: AES-GCM.
-  /// \param[in] cropto_lib_path Define the openssl library path.
-  ///
-  /// \return Status.
+  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kMindIR_Lite. Only
+  /// ModelType::kMindIR_Lite is valid for Device-side Inference. Cloud-side Inference supports options
+  /// ModelType::kMindIR and ModelType::kMindIR_Lite, but option odelType::kMindIR_Lite will be removed in future
+  /// iterations. \param[in] model_context Define the context used to store options during execution. \param[in] dec_key
+  /// Define the key used to decrypt the ciphertext model. The key length is 16. \param[in] dec_mode Define the
+  /// decryption mode. Options: AES-GCM. \param[in] cropto_lib_path Define the openssl library path.
+  ///
+  /// \return Status. kSuccess: build success, kLiteModelRebuild: build model repeatedly, Other: other types of errors.
   inline Status Build(const void *model_data, size_t data_size, ModelType model_type,
                       const std::shared_ptr<Context> &model_context, const Key &dec_key, const std::string &dec_mode,
                       const std::string &cropto_lib_path);
@@ -90,14 +86,14 @@ class MS_API Model {
   /// \brief Load and build a model from model buffer so that it can run on a device.
   ///
   /// \param[in] model_path Define the model path.
-  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kOM. Only
-  /// ModelType::kMindIR is valid for Lite.
-  /// \param[in] model_context Define the context used to store options during execution.
-  /// \param[in] dec_key Define the key used to decrypt the ciphertext model. The key length is 16.
-  /// \param[in] dec_mode Define the decryption mode. Options: AES-GCM.
-  /// \param[in] cropto_lib_path Define the openssl library path.
-  ///
-  /// \return Status.
+  /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR, ModelType::kMindIR_Lite. Only
+  /// ModelType::kMindIR_Lite is valid for Device-side Inference. Cloud-side Inference supports options
+  /// ModelType::kMindIR and ModelType::kMindIR_Lite, but option odelType::kMindIR_Lite will be removed in future
+  /// iterations. \param[in] model_context Define the context used to store options during execution. \param[in] dec_key
+  /// Define the key used to decrypt the ciphertext model. The key length is 16. \param[in] dec_mode Define the
+  /// decryption mode. Options: AES-GCM. \param[in] cropto_lib_path Define the openssl library path.
+  ///
+  /// \return Status. kSuccess: build success, kLiteModelRebuild: build model repeatedly, Other: other types of errors.
   inline Status Build(const std::string &model_path, ModelType model_type,
                       const std::shared_ptr<Context> &model_context, const Key &dec_key, const std::string &dec_mode,
                       const std::string &cropto_lib_path);
@@ -113,17 +109,6 @@ class MS_API Model {
   Status Build(GraphCell graph, const std::shared_ptr<Context> &model_context = nullptr,
                const std::shared_ptr<TrainCfg> &train_cfg = nullptr);
 
-  /// \brief Build train model
-  ///
-  /// \param[in] graph A forward network
-  /// \param[in] optimizer An optimizer node
-  /// \param[in] inputs Inputs expression for the trained network (ex: input, label )
-  /// \param[in] model_context A context used to store options during execution.
-  /// \param[in] train_cfg A config used by training
-  /// \return Status
-
-  Status Build(GraphCell graph, Node *optimizer, std::vector<Expr *> inputs,
-               const std::shared_ptr<Context> &model_context, const std::shared_ptr<TrainCfg> &train_cfg);
   /// \brief Build a Transfer Learning model where the backbone weights are fixed and the head weights are trainable
   ///
   /// \param[in] backbone The static, non-learnable part of the graph
@@ -290,7 +275,7 @@ class MS_API Model {
 
   /// \brief Initialize object with metrics.
   ///
-  /// \param[in] metrics A verctor of metrics objects.
+  /// \param[in] metrics A vector of metrics objects.
   ///
   /// \return 0 on success or -1 in case of error
   Status InitMetrics(std::vector<Metrics *> metrics);
@@ -371,6 +356,8 @@ class MS_API Model {
   /// \return Status of operation.
   Status Evaluate(std::shared_ptr<dataset::Dataset> ds, std::vector<TrainCallBack *> cbs);
 
+  const std::shared_ptr<ModelImpl> impl() const { return impl_; }
+
  private:
   friend class Serialization;
   // api without std::string

mindspore/include/api/model_group.h

@@ -31,12 +31,16 @@ class ModelGroupImpl;
 
 /// \brief The ModelGroup class is used to define a MindSpore model group, facilitating
 /// multiple models to share workspace memory.
+
+enum class ModelGroupFlag : int {
+  kShareWeight = 0x0001,
+  kShareWorkspace = 0x0002,
+};
+
 class MS_API ModelGroup {
  public:
-  ModelGroup();
+  explicit ModelGroup(ModelGroupFlag flags = ModelGroupFlag::kShareWorkspace);
   ~ModelGroup() = default;
-  ModelGroup(const ModelGroup &) = delete;
-  ModelGroup &operator=(const ModelGroup &) = delete;
 
   /// \brief Add models that require shared workspace memory.
   ///
@@ -52,6 +56,13 @@ class MS_API ModelGroup {
   /// \return Status.
   Status AddModel(const std::vector<std::pair<const void *, size_t>> &model_buff_list);
 
+  /// \brief Add models that require shared weight memory.
+  ///
+  /// \param[in] model_list Define the list of model object.
+  ///
+  /// \return Status.
+  Status AddModel(const std::vector<Model> &model_list);
+
   /// \brief Calculate the max workspace of the added models.
   ///
   /// \param[in] model_type Define The type of model file. Options: ModelType::kMindIR_Lite, ModelType::kMindIR. Only

mindspore/include/api/model_parallel_runner.h

@@ -72,6 +72,17 @@ class MS_API RunnerConfig {
   /// \return The current config path.
   inline std::string GetConfigPath() const;
 
+  /// \brief Set the device id list at runtime, make the model run on different npu/gpu devices. Only valid for
+  /// ModelParallelRunner.
+  ///
+  /// \param[in] device_ids The device id list at runtime.
+  void SetDeviceIds(const std::vector<uint32_t> &device_ids);
+
+  /// \brief Get the device id list at runtime. Only valid for ModelParallelRunner.
+  ///
+  /// \return The device id list.
+  std::vector<uint32_t> GetDeviceIds() const;
+
  private:
   void SetConfigInfo(const std::vector<char> &section, const std::map<std::vector<char>, std::vector<char>> &config);
   std::map<std::vector<char>, std::map<std::vector<char>, std::vector<char>>> GetConfigInfoChar() const;
@@ -101,7 +112,11 @@ class MS_API ModelParallelRunner {
   ModelParallelRunner();
   ~ModelParallelRunner();
 
-  /// \brief build a model parallel runner from model path so that it can run on a device.
+  /// \brief build a model parallel runner from model path so that it can run on a device. Supports importing the `ms`
+  /// model (exported by the `converter_lite` tool) and the `mindir` model (exported by MindSpore or exported by the
+  /// `converter_lite` tool). The support for the `ms` model will be removed in future iterations, and it is recommended
+  /// to use the `mindir` model for inference. When using the `ms` model for inference, please keep the suffix name of
+  /// the model as `.ms`, otherwise it will not be recognized.
   ///
   /// \param[in] model_path Define the model path.
   /// \param[in] runner_config Define the config used to store options during model pool init.
@@ -109,7 +124,8 @@ class MS_API ModelParallelRunner {
   /// \return Status.
   inline Status Init(const std::string &model_path, const std::shared_ptr<RunnerConfig> &runner_config = nullptr);
 
-  /// \brief build a model parallel runner from model buffer so that it can run on a device.
+  /// \brief build a model parallel runner from model buffer so that it can run on a device. This interface only
+  /// supports passing in `mindir` model file data.
   ///
   /// \param[in] model_data Define the buffer read from a model file.
   /// \param[in] data_size Define bytes number of model buffer.

mindspore/include/api/serialization.h

@@ -105,6 +105,21 @@ class MS_API Serialization {
                                    QuantizationType quantization_type = kNoQuant, bool export_inference_only = true,
                                    std::vector<std::string> output_tensor_name = {});
 
+  /// \brief Experimental feature. Export model's weights, which can be used in micro only.
+  ///
+  /// \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.
+  ///
+  /// \return Status.
+  inline static Status ExportWeightsCollaborateWithMicro(const Model &model, ModelType model_type,
+                                                         const std::string &weight_file, bool is_inference = true,
+                                                         bool enable_fp16 = false,
+                                                         const std::vector<std::string> &changeable_weights_name = {});
+
  private:
   static Status Load(const void *model_data, size_t data_size, ModelType model_type, Graph *graph, const Key &dec_key,
                      const std::vector<char> &dec_mode);
@@ -120,6 +135,10 @@ class MS_API Serialization {
   static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data,
                             QuantizationType quantization_type, bool export_inference_only,
                             const std::vector<std::vector<char>> &output_tensor_name);
+  static Status ExportWeightsCollaborateWithMicro(const Model &model, ModelType model_type,
+                                                  const std::vector<char> &weight_file, bool is_inference,
+                                                  bool enable_fp16,
+                                                  const std::vector<std::vector<char>> &changeable_weights_name);
 };
 
 Status Serialization::Load(const void *model_data, size_t data_size, ModelType model_type, Graph *graph,
@@ -155,5 +174,12 @@ Status Serialization::ExportModel(const Model &model, ModelType model_type, Buff
                      VectorStringToChar(output_tensor_name));
 }
 
+Status Serialization::ExportWeightsCollaborateWithMicro(const Model &model, ModelType model_type,
+                                                        const std::string &weight_file, bool is_inference,
+                                                        bool enable_fp16,
+                                                        const std::vector<std::string> &changeable_weights_name) {
+  return ExportWeightsCollaborateWithMicro(model, model_type, StringToChar(weight_file), is_inference, enable_fp16,
+                                           VectorStringToChar(changeable_weights_name));
+}
 }  // namespace mindspore
 #endif  // MINDSPORE_INCLUDE_API_SERIALIZATION_H

mindspore/include/api/status.h

@@ -80,6 +80,7 @@ enum StatusCode : uint32_t {
   kLiteUninitializedObj = kLite | (0x0FFFFFFF & -9), /**< Object is not initialized. */
   kLiteFileError = kLite | (0x0FFFFFFF & -10),       /**< Invalid file. */
   kLiteServiceDeny = kLite | (0x0FFFFFFF & -11),     /**< Denial of service. */
+  kLiteModelRebuild = kLite | (0x0FFFFFFF & -12),    /**< Model has been built. */
 
   // Executor error code, range: [-100,-200)
   kLiteOutOfTensorRange = kLite | (0x0FFFFFFF & -100), /**< Failed to check range. */

mindspore/include/api/types.h

@@ -33,6 +33,7 @@ enum ModelType : uint32_t {
   kOM = 2,                   ///< Model type is OM
   kONNX = 3,                 ///< Model type is ONNX
   kMindIR_Lite = 4,          ///< Model type is MindIR_LITE
+  kDataFlow = 5,             ///< Model type is DataFlow
   kUnknownType = 0xFFFFFFFF  ///< Unknown model type
 };
 
@@ -72,10 +73,25 @@ class MS_API MSTensor {
   /// \param[in] shape The shape of the MSTensor.
   /// \param[in] data The data pointer that points to allocated memory.
   /// \param[in] data_len The length of the memory, in bytes.
+  /// \param[in] device The tensor of device type.
+  /// \param[in] device_id The tensor of device id.
   ///
   /// \return A pointer of MSTensor.
   static inline MSTensor *CreateTensor(const std::string &name, DataType type, const std::vector<int64_t> &shape,
-                                       const void *data, size_t data_len) noexcept;
+                                       const void *data, size_t data_len, const std::string &device = "",
+                                       int device_id = -1) noexcept;
+
+  /// \brief Creates a MSTensor object, whose data need to be copied before accessed by Model, must be used in pairs
+  /// with DestroyTensorPtr.
+  ///
+  /// \param[in] name The name of the MSTensor.
+  /// \param[in] tensor The src tensor.
+  /// \param[in] device The tensor of device type.
+  /// \param[in] device_id The tensor of device id.
+  ///
+  /// \return A pointer of MSTensor.
+  static inline MSTensor *CreateTensor(const std::string &name, const MSTensor &tensor, const std::string &device = "",
+                                       int device_id = -1) noexcept;
 
   /// \brief Creates a MSTensor object, whose data can be directly accessed by Model, must be used in pairs with
   /// DestroyTensorPtr.
@@ -180,6 +196,16 @@ class MS_API MSTensor {
   /// \return The length of the data of the MSTensor, in bytes.
   size_t DataSize() const;
 
+  /// \brief Get the MSTensor device id
+  ///
+  /// \return device id of MSTensor
+  int GetDeviceId() const;
+
+  /// \brief Get the MSTensor device type
+  ///
+  /// \return device type of MSTensor
+  std::string GetDevice() const;
+
   /// \brief Get whether the MSTensor data is const data
   ///
   /// \return Const flag of MSTensor
@@ -293,7 +319,10 @@ class MS_API MSTensor {
  private:
   // api without std::string
   static MSTensor *CreateTensor(const std::vector<char> &name, enum DataType type, const std::vector<int64_t> &shape,
-                                const void *data, size_t data_len) noexcept;
+                                const void *data, size_t data_len, const std::vector<char> &device = {},
+                                int device_id = -1) noexcept;
+  static MSTensor *CreateTensor(const std::vector<char> &name, const MSTensor &tensor, const std::vector<char> &device,
+                                int device_id = -1) noexcept;
   static MSTensor *CreateRefTensor(const std::vector<char> &name, enum DataType type, const std::vector<int64_t> &shape,
                                    const void *data, size_t data_len, bool own_data) noexcept;
   static MSTensor CreateDeviceTensor(const std::vector<char> &name, enum DataType type,
@@ -333,8 +362,13 @@ class MS_API Buffer {
 };
 
 MSTensor *MSTensor::CreateTensor(const std::string &name, enum DataType type, const std::vector<int64_t> &shape,
-                                 const void *data, size_t data_len) noexcept {
-  return CreateTensor(StringToChar(name), type, shape, data, data_len);
+                                 const void *data, size_t data_len, const std::string &device, int device_id) noexcept {
+  return CreateTensor(StringToChar(name), type, shape, data, data_len, StringToChar(device), device_id);
+}
+
+MSTensor *MSTensor::CreateTensor(const std::string &name, const MSTensor &tensor, const std::string &device,
+                                 int device_id) noexcept {
+  return CreateTensor(StringToChar(name), tensor, StringToChar(device), device_id);
 }
 
 MSTensor *MSTensor::CreateRefTensor(const std::string &name, enum DataType type, const std::vector<int64_t> &shape,

mindspore/include/c_api/ms/abstract.h

@@ -0,0 +1,67 @@
+/**
+ * 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_ABSTRACT_H_
+#define MINDSPORE_CCSRC_C_API_INCLUDE_ABSTRACT_H_
+
+#include <stdlib.h>
+#include "include/c_api/ms/base/macros.h"
+#include "include/c_api/ms/base/types.h"
+#include "include/c_api/ms/base/handle_types.h"
+#include "include/c_api/ms/base/status.h"
+#include "include/c_api/ms/context.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// \brief Assign Abstract from the input node to the current node.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] cur_node The current node.
+/// \param[in] input_node The input node which contains the Abstract.
+///
+/// \return Error code indicates whether the function executed successfully.
+MIND_C_API STATUS MSAssignAbstract(ResMgrHandle res_mgr, NodeHandle cur_node, ConstNodeHandle input_node);
+
+/// \brief Set Abstract to the node with type and shape.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] node The target node.
+/// \param[in] type The output type of the node.
+/// \param[in] shape The shape array which describe the output shape of node.
+/// \param[in] shape_size The size of the shape array, i.e., the dimension of node output.
+///
+/// \return Error code indicates whether the function executed successfully.
+MIND_C_API STATUS MSSetAbstract(ResMgrHandle res_mgr, NodeHandle node, DataTypeC type, const int64_t shape[],
+                                size_t shape_size);
+
+/// \brief Get multiple Abstract to the node. Usually used in the case that the node has multiple outputs.
+///
+/// \param[in] res_mgr Resource manager that saves allocated instance resources.
+/// \param[in] node The target node.
+/// \param[in] type The output type of the node.
+/// \param[in] shapes A 2D array which contains multiple shape arrays response to node's multiple outputs.
+/// \param[in] shape_sizes The array contains the size of all shape, i.e., the dimension of all node output.
+///
+/// \return Error code indicates whether the function executed successfully.
+MIND_C_API STATUS MSSetMultiAbstract(ResMgrHandle res_mgr, NodeHandle node, DataTypeC type, const int64_t **shapes,
+                                     const size_t shape_sizes[], size_t abs_num);
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // MINDSPORE_CCSRC_C_API_INCLUDE_ABSTRACT_H_