interpret.h

Go to the documentation of this file.

 
#ifndef _NNDEPLOY_IR_INTERPRET_H_
#define _NNDEPLOY_IR_INTERPRET_H_
 
#include "nndeploy/ir/ir.h"
 
namespace nndeploy {
namespace ir {
 
class NNDEPLOY_CC_API Interpret {
 public:
  // Interpret();
 
  explicit Interpret(ModelDesc *model_desc = nullptr, bool is_external = false);
 
  virtual ~Interpret();
 
  virtual base::Status interpret(
      const std::vector<std::string> &model_value,
      const std::vector<ValueDesc> &input = std::vector<ValueDesc>()) = 0;
 
  // 打印模型结构
  base::Status dump(std::ostream &oss = std::cout);
 
#ifdef ENABLE_NNDEPLOY_SAFETENSORS_CPP
  base::Status saveModel(std::string &structure_str,
                         std::shared_ptr<safetensors::safetensors_t> st_ptr);
#endif
  base::Status saveModelToFile(const std::string &structure_file_path,
                               const std::string &weight_file_path);
 
  ModelDesc *getModelDesc();
 
 public:
  ModelDesc *model_desc_ = nullptr;
 
  bool is_external_ = false;
};
 
class InterpretCreator {
 public:
  virtual ~InterpretCreator() {};
  // virtual Interpret *createInterpret(base::ModelType type) = 0;
  virtual Interpret *createInterpret(base::ModelType type,
                                     ir::ModelDesc *model_desc = nullptr,
                                     bool is_external = false) = 0;
  virtual std::shared_ptr<Interpret> createInterpretSharedPtr(
      base::ModelType type, ir::ModelDesc *model_desc = nullptr,
      bool is_external = false) = 0;
};
 
template <typename T>
class TypeInterpretCreator : public InterpretCreator {
  virtual Interpret *createInterpret(base::ModelType type,
                                     ir::ModelDesc *model_desc = nullptr,
                                     bool is_external = false) {
    return new T(model_desc, is_external);
  }
  virtual std::shared_ptr<Interpret> createInterpretSharedPtr(
      base::ModelType type, ir::ModelDesc *model_desc = nullptr,
      bool is_external = false) {
    return std::make_shared<T>(model_desc, is_external);
  }
};
 
extern NNDEPLOY_CC_API
    std::map<base::ModelType, std::shared_ptr<InterpretCreator>> &
    getGlobalInterpretCreatorMap();
 
template <typename T>
class TypeInterpretRegister {
 public:
  explicit TypeInterpretRegister(base::ModelType type) {
    getGlobalInterpretCreatorMap()[type] = std::shared_ptr<T>(new T());
  }
};
 
extern NNDEPLOY_CC_API Interpret *createInterpret(
    base::ModelType type, ir::ModelDesc *model_desc = nullptr,
    bool is_external = false);
 
extern NNDEPLOY_CC_API std::shared_ptr<Interpret> createInterpretSharedPtr(
    base::ModelType type, ir::ModelDesc *model_desc = nullptr,
    bool is_external = false);
 
}  // namespace ir
}  // namespace nndeploy
 
#endif /* _NNDEPLOY_IR_INTERPRET_H_ */