diff --git a/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.cc b/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.cc
index afa74986413852b75183f3629c4499ab7f47e0df..fa61ef726ac72485ae7483bd0839e9813d68c025 100644
--- a/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.cc
+++ b/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.cc
@@ -72,7 +72,7 @@ std::unordered_map<AnfNodePtr, NodeInfo> CollectNodeInfo(const FuncGraphPtr &fun
     }
 
     if (!AnfAlgo::IsRealKernel(node)) {
-      res[node] = NodeInfo(NodeType::kSupport, i);
+      res[node] = NodeInfo(MSNodeType::kSupport, i);
       continue;
     }
 
@@ -80,12 +80,12 @@ std::unordered_map<AnfNodePtr, NodeInfo> CollectNodeInfo(const FuncGraphPtr &fun
     const auto &converter_factory = TrtOpFactory::GetInstance();
     ConvertFunc convert_func = converter_factory.GetConvertFunc(op_name);
     if (!convert_func) {
-      res[node] = NodeInfo(NodeType::kUnsupported, i);
+      res[node] = NodeInfo(MSNodeType::kUnsupported, i);
       continue;
     }
 
     // Trt requires certain input to be weight.
-    res[node] = WeightCheck(node) ? NodeInfo(NodeType::kSupport, i) : NodeInfo(NodeType::kUnsupported, i);
+    res[node] = WeightCheck(node) ? NodeInfo(MSNodeType::kSupport, i) : NodeInfo(MSNodeType::kUnsupported, i);
   }
 
   return res;
@@ -128,8 +128,8 @@ void GraphPartitioner::NewSubGraph(NodeInfo *node_info) {
   static size_t trt_id = 0;
   static size_t native_id = 0;
 
-  node_info->graph_id_ = node_info->type() == NodeType::kSupport ? std::string("T_") + std::to_string(trt_id++)
-                                                                 : std::string("N_") + std::to_string(native_id++);
+  node_info->graph_id_ = node_info->type() == MSNodeType::kSupport ? std::string("T_") + std::to_string(trt_id++)
+                                                                   : std::string("N_") + std::to_string(native_id++);
 }
 
 bool GraphPartitioner::ExistCycleAfterMerge(const AnfNodePtr &node, const std::string &target_graph_id) {
diff --git a/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.h b/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.h
index 0eb38f4abc0c02f0242065f0baf830020f5eaab4..de1a3d29c87f9307bfe810306060ed27ee6a9a9b 100644
--- a/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.h
+++ b/mindspore/ccsrc/backend/optimizer/trt_pass/graph_partitioner.h
@@ -34,7 +34,7 @@ enum class NodeType : char {
 
 // Class keep node information about type, topo index, and sub graph id.
 struct NodeInfo {
-  NodeInfo() : topo_index_(0), type_(NodeType::kInvalid), graph_id_(""), final_(false) {}
+  NodeInfo() : topo_index_(0), type_(MSNodeType::kInvalid), graph_id_(""), final_(false) {}
   explicit NodeInfo(const NodeType &t, const size_t &i) : topo_index_(i), type_(t), graph_id_(""), final_(false) {}
 
   const size_t topo_index() const { return topo_index_; }
diff --git a/mindspore/ccsrc/frontend/optimizer/irpass/less_batch_normalization.cc b/mindspore/ccsrc/frontend/optimizer/irpass/less_batch_normalization.cc
index 8fd894b408a156c08950f0e71869ece24b8901de..e7e6298e591fcd44add33e2532b55c7cba7e80ff 100644
--- a/mindspore/ccsrc/frontend/optimizer/irpass/less_batch_normalization.cc
+++ b/mindspore/ccsrc/frontend/optimizer/irpass/less_batch_normalization.cc
@@ -251,7 +251,7 @@ const std::set<PrimitivePtr> kNeedRemoveNodeSet{
   prim::kPrimLoad,      prim::kPrimRefToEmbed, prim::kPrimApplyMomentum, prim::kPrimMomentum,
   prim::kPrimApplyFtrl, prim::kPrimSGD,        prim::kPrimApplyRMSProp,  prim::kPrimAdam};
 static std::unordered_map<RemoveNodeType, std::unordered_set<size_t>> kRemoveIndex{
-  {RemoveNodeType::kOtherNode, {2}}, {RemoveNodeType::kOptimizerNode, {3, 5, 6}}};
+  {RemoveMSNodeType::kOtherNode, {2}}, {RemoveMSNodeType::kOptimizerNode, {3, 5, 6}}};
 
 bool NeedRemove(const ParameterPtr &a, const std::vector<AnfNodePtr> &parameter_list) {
   if (a == nullptr) {
@@ -276,9 +276,9 @@ CNodePtr ConvertRemoveNodeToVirtualNode(const CNodePtr &cnode) {
   std::vector<AnfNodePtr> args;
   size_t index = 0;
   const auto &inputs = cnode->inputs();
-  auto remove_index = kRemoveIndex[RemoveNodeType::kOptimizerNode];
+  auto remove_index = kRemoveIndex[RemoveMSNodeType::kOptimizerNode];
   if (IsPrimitiveCNode(cnode, prim::kPrimLoad) || IsPrimitiveCNode(cnode, prim::kPrimRefToEmbed)) {
-    remove_index = kRemoveIndex[RemoveNodeType::kOtherNode];
+    remove_index = kRemoveIndex[RemoveMSNodeType::kOtherNode];
   }
 
   (void)std::copy_if(
diff --git a/mindspore/lite/include/lite_utils.h b/mindspore/lite/include/lite_utils.h
index 0c34601f1c329de8b5a987a85c29b88ecd48fecf..0b6d1a2337f98bbe8331761586f99375d91967c1 100644
--- a/mindspore/lite/include/lite_utils.h
+++ b/mindspore/lite/include/lite_utils.h
@@ -619,6 +619,7 @@ using AllocatorPtr = std::shared_ptr<Allocator>;
 class Delegate;
 using DelegatePtr = std::shared_ptr<Delegate>;
 
+// using TensorPtrVector = std::vector<mindspore::schema::Tensor *>;
 using TensorPtrVector = std::vector<void *>;
 using Uint32Vector = std::vector<uint32_t>;
 template <typename T>
diff --git a/mindspore/lite/micro/coder/graph.cc b/mindspore/lite/micro/coder/graph.cc
index 350df107b9af7f542c78ccfb86f1c66bc044dc20..5b272e3fdb96e10758fa64756bff4c1daa30f5a4 100644
--- a/mindspore/lite/micro/coder/graph.cc
+++ b/mindspore/lite/micro/coder/graph.cc
@@ -60,9 +60,9 @@ int CoderGraph::ConvertTensors() {
   };
 
   // deal with allTensors
-  uint32_t tensorCount = model_->all_tensors_.size();
+  uint32_t tensorCount = model_->graph_.all_tensors_.size();
   for (uint32_t i = 0; i < tensorCount; ++i) {
-    schema::Tensor *origin_tensor = model_->all_tensors_.at(i);
+    schema::Tensor *origin_tensor = static_cast<schema::Tensor *>(model_->graph_.all_tensors_.at(i));
     MS_CHECK_PTR_WITH_EXE(origin_tensor, clear_tensors());
     // tensor dims
     std::vector<int> shape;
@@ -83,7 +83,7 @@ int CoderGraph::ConvertTensors() {
       lite::Tensor(TypeId(origin_data_type), shape, static_cast<mindspore::Format>(origin_tensor->format()),
                    TensorCategory(origin_tensor));
     MS_CHECK_PTR(dstTensor);
-    if (origin_tensor->nodeType() == NodeType_ValueNode && origin_tensor->data() != nullptr &&
+    if ((MSNodeType)origin_tensor->nodeType() == MSNodeType::NodeType_ValueNode && origin_tensor->data() != nullptr &&
         origin_tensor->data()->size() > 0) {
       // copy data, this is weight && bias
       MS_CHECK_TRUE_WITH_EXE(origin_tensor->data()->size() > 0, "invalid meta_tensor data size.", delete dstTensor);
@@ -132,13 +132,13 @@ int CoderGraph::InitGraphInOutTensors() {
   std::vector<uint32_t> input_indices;
   for (auto in_node_index : graph_input_node_indexes) {
     in_node_index = static_cast<uint32_t>(in_node_index);
-    auto in_node = model_->all_nodes_.at(in_node_index);
+    auto in_node = model_->graph_.all_nodes_.at(in_node_index);
     MS_CHECK_PTR(in_node);
     for (uint32_t i = 0; i < in_node->input_indices_.size(); i++) {
       auto in_tensor_index = size_t(in_node->input_indices_.at(i));
       bool is_graph_input = false;
-      for (uint32_t j = 0; j < model_->input_indices_.size(); j++) {
-        if (in_tensor_index == size_t(model_->input_indices_.at(j))) {
+      for (uint32_t j = 0; j < model_->graph_.input_indices_.size(); j++) {
+        if (in_tensor_index == size_t(model_->graph_.input_indices_.at(j))) {
           input_indices.push_back(static_cast<uint32_t>(in_tensor_index));
           is_graph_input = true;
           break;
@@ -158,12 +158,12 @@ int CoderGraph::InitGraphInOutTensors() {
   auto graph_output_node_indexes = lite::GetGraphOutputNodes(model_);
   for (auto out_node_index : graph_output_node_indexes) {
     out_node_index = static_cast<uint32_t>(out_node_index);
-    auto *out_node = model_->all_nodes_.at(out_node_index);
+    auto *out_node = model_->graph_.all_nodes_.at(out_node_index);
     for (uint32_t i = 0; i < out_node->output_indices_.size(); i++) {
       auto out_tensor_index = size_t(out_node->output_indices_.at(i));
       bool is_graph_output = false;
-      for (uint32_t j = 0; j < model_->output_indices_.size(); j++) {
-        if (out_tensor_index == size_t(model_->output_indices_.at(j))) {
+      for (uint32_t j = 0; j < model_->graph_.output_indices_.size(); j++) {
+        if (out_tensor_index == size_t(model_->graph_.output_indices_.at(j))) {
           output_indices.push_back(static_cast<uint32_t>(out_tensor_index));
           is_graph_output = true;
           break;
@@ -247,22 +247,23 @@ std::vector<uint32_t> CoderGraph::output_indices() const { return this->output_i
 
 void CoderGraph::DumpUnSupportLayer(Target target) {
   std::cerr << "==========dump all unsupported layer for codegen=====" << std::endl;
-  std::for_each(model_->all_nodes_.begin(), model_->all_nodes_.end(), [this, target](const Model::Node *node) {
-    if (node->primitive_ == nullptr) {
-      return;
-    }
-    // fake create opcoders
-    uint32_t input_idx = node->input_indices_.at(0);
-    Tensor *t = all_tensors_.at(input_idx);
-    TypeId dtype = t->data_type();
-    int pt = GetPrimitiveType(node->primitive_, reinterpret_cast<lite::LiteModel *>(model_)->GetSchemaVersion());
-    CoderKey key(target, dtype, pt);
-    // search from the opcoder registry
-    if (OpCoderFactory::GetInstance()->FindOpCoder(key) == nullptr) {
-      std::cerr << node->name_ << ", primitive type: "
-                << mindspore::schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(pt))
-                << ", data_type: " << EnumNameDataType(dtype) << std::endl;
-    }
-  });
+  std::for_each(
+    model_->graph_.all_nodes_.begin(), model_->graph_.all_nodes_.end(), [this, target](const LiteGraph::Node *node) {
+      if (node->primitive_ == nullptr) {
+        return;
+      }
+      // fake create opcoders
+      uint32_t input_idx = node->input_indices_.at(0);
+      Tensor *t = all_tensors_.at(input_idx);
+      TypeId dtype = t->data_type();
+      int pt = GetPrimitiveType(node->primitive_, reinterpret_cast<lite::LiteModel *>(model_)->GetSchemaVersion());
+      CoderKey key(target, dtype, pt);
+      // search from the opcoder registry
+      if (OpCoderFactory::GetInstance()->FindOpCoder(key) == nullptr) {
+        std::cerr << node->name_ << ", primitive type: "
+                  << mindspore::schema::EnumNamePrimitiveType(static_cast<schema::PrimitiveType>(pt))
+                  << ", data_type: " << EnumNameDataType(dtype) << std::endl;
+      }
+    });
 }
 }  // namespace mindspore::lite::micro
diff --git a/mindspore/lite/micro/coder/opcoders/base/conv2d_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/conv2d_base_coder.h
index e226c1b9e22e6d3be006495c1cc960f170047bfa..ff5ea1871b0da0e0ec45c4fef1ffc0d430d8685d 100644
--- a/mindspore/lite/micro/coder/opcoders/base/conv2d_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/conv2d_base_coder.h
@@ -29,7 +29,7 @@ namespace mindspore::lite::micro {
 class Conv2DBaseCoder : public OperatorCoder {
  public:
   Conv2DBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~Conv2DBaseCoder() override;
diff --git a/mindspore/lite/micro/coder/opcoders/base/detection_post_process_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/detection_post_process_base_coder.h
index dceaaf562e25c228d86f576c68878afecbcd0bdc..f0c8c669ce3181de8a1491fb68e8d6ac9ada2736 100644
--- a/mindspore/lite/micro/coder/opcoders/base/detection_post_process_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/detection_post_process_base_coder.h
@@ -30,7 +30,7 @@ namespace mindspore::lite::micro {
 class DetectionPostProcessBaseCoder : public OperatorCoder {
  public:
   DetectionPostProcessBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                                const Model::Node *node, size_t node_index, Target target)
+                                const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~DetectionPostProcessBaseCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/base/dtype_cast_coder.h b/mindspore/lite/micro/coder/opcoders/base/dtype_cast_coder.h
index 86087e61dcd5936a947fec96d62f0a712b406710..2affc4c722b5374ec30b482601233e80001f93a4 100644
--- a/mindspore/lite/micro/coder/opcoders/base/dtype_cast_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/dtype_cast_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro {
 class DTypeCastCoder final : public OperatorCoder {
  public:
   DTypeCastCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                 const Model::Node *node, size_t node_index, Target target)
+                 const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~DTypeCastCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/base/full_connection_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/full_connection_base_coder.h
index 41a2f2e25fbdc7e70ba2bc50883e48641937ecf4..99fe4edb06930cc3352c9f801872d25386912559 100644
--- a/mindspore/lite/micro/coder/opcoders/base/full_connection_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/full_connection_base_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro {
 class FullConnectionBaseCoder : public OperatorCoder {
  public:
   FullConnectionBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                          const Model::Node *node, size_t node_index, Target target)
+                          const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~FullConnectionBaseCoder() override;
diff --git a/mindspore/lite/micro/coder/opcoders/base/quant_dtype_cast_coder.h b/mindspore/lite/micro/coder/opcoders/base/quant_dtype_cast_coder.h
index 276f6c967d024d36a19a91420180593c28bba44a..8f74f514539846471b63b2f79f13419052d42035 100644
--- a/mindspore/lite/micro/coder/opcoders/base/quant_dtype_cast_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/quant_dtype_cast_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro {
 class QuantDTypeCastCoder final : public OperatorCoder {
  public:
   QuantDTypeCastCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                      const Model::Node *node, size_t node_index, Target target)
+                      const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~QuantDTypeCastCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/base/reduce_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/reduce_base_coder.h
index b942c31bb94401e360c1a80a4db295b5afb033e7..11f7887f8f44f224dde4da5fe86b33cca32b1362 100644
--- a/mindspore/lite/micro/coder/opcoders/base/reduce_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/reduce_base_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro {
 class ReduceBaseCoder : public OperatorCoder {
  public:
   ReduceBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReduceBaseCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/base/reshape_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/reshape_base_coder.h
index 5bb1dfcd8016cbf0180197a4555b219e97d0c698..767363e969f1401288d59ea7bad13844ebf7352c 100644
--- a/mindspore/lite/micro/coder/opcoders/base/reshape_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/reshape_base_coder.h
@@ -24,7 +24,7 @@ namespace mindspore::lite::micro {
 class ReshapeBaseCoder final : public OperatorCoder {
  public:
   ReshapeBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReshapeBaseCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/base/resize_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/resize_base_coder.h
index 1d2ccdc05a3042f0268c5bfc097876f0452efc10..dac371de9e98c384dbb782511e76cfebefcf251a 100644
--- a/mindspore/lite/micro/coder/opcoders/base/resize_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/resize_base_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro {
 class ResizeBaseCoder : public OperatorCoder {
  public:
   ResizeBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ResizeBaseCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/base/softmax_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/softmax_base_coder.h
index 79941dfbfc0ac24609108c120ca5fb832bc31390..bfd84f7bf10edeb3fd5671855c22a5dd648b430b 100644
--- a/mindspore/lite/micro/coder/opcoders/base/softmax_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/softmax_base_coder.h
@@ -28,7 +28,7 @@ namespace mindspore::lite::micro {
 class SoftmaxBaseCoder : public OperatorCoder {
  public:
   SoftmaxBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~SoftmaxBaseCoder() override { softmax_param_ = nullptr; }
diff --git a/mindspore/lite/micro/coder/opcoders/base/strided_slice_base_coder.h b/mindspore/lite/micro/coder/opcoders/base/strided_slice_base_coder.h
index 761f00aea8b795254e811f48dd31c6ecc0c178ad..9873d217d72f057a0613983925e312583a1387d3 100644
--- a/mindspore/lite/micro/coder/opcoders/base/strided_slice_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/base/strided_slice_base_coder.h
@@ -22,7 +22,7 @@ namespace mindspore::lite::micro {
 class StridedSliceBaseCoder final : public OperatorCoder {
  public:
   StridedSliceBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                        const Model::Node *node, size_t node_index, Target target)
+                        const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~StridedSliceBaseCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/add_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/add_int8_coder.h
index 5fc681725f8514392b5d5a68ee4dd0ad6cb6547c..91c0d97f74fbe0cfcc64143edd959cf17a8806fa 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/add_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/add_int8_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::cmsis {
 class AddInt8Coder final : public OperatorCoder {
  public:
   AddInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-               const Model::Node *node, size_t node_index, Target target)
+               const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~AddInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_base_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_base_coder.h
index 588d50b32bbd76691907a9498e3513804ac2edb5..74d1aa5378d32fd611a575aa5c8ec3036ad03fe4 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_base_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::cmsis {
 class Conv2DBaseCoder : public micro::Conv2DBaseCoder {
  public:
   explicit Conv2DBaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                           const Model::Node *node, size_t node_index, Target target)
+                           const LiteGraph::Node *node, size_t node_index, Target target)
       : micro::Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~Conv2DBaseCoder() override {
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.cc b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.cc
index aa5d1aa86e656794921ccf921e28d488746accaa..c0ed63c5c59c2d977651113adc3ce3c8b8dcb853 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.cc
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.cc
@@ -174,8 +174,8 @@ int Conv2DInt8Coder::InitTmpBuffer() {
 
 std::unique_ptr<OperatorCoder> CmsisConv2DInt8OpCoderCreator(const std::vector<Tensor *> &in_tensors,
                                                              const std::vector<Tensor *> &out_tensors,
-                                                             const Model::Node *node, size_t node_index, Target target,
-                                                             int schema_version) {
+                                                             const LiteGraph::Node *node, size_t node_index,
+                                                             Target target, int schema_version) {
   MS_CHECK_PTR_RET_NULL(node);
   std::unique_ptr<Conv2DInt8Coder> coder =
     std::make_unique<Conv2DInt8Coder>(in_tensors, out_tensors, node, node_index, target);
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.h
index 7d4ad6eeb9b58de7589944801d7e5ca5e9a53dea..f7a470e0ada41f04aeffff87f7b6e7f7bd8f00ef 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/conv2d_int8_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::cmsis {
 class Conv2DInt8Coder final : public Conv2DBaseCoder {
  public:
   explicit Conv2DInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                           const Model::Node *node, size_t node_index, Target target)
+                           const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
   int Prepare(CoderContext *context) override;
 
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/dwconv_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/dwconv_int8_coder.h
index 7bfd7fa0d4f4a79c63a1a8fbe94da0a53f03e82b..18b61628d5bf2fffe6f862bc59f8b741f1f83ff0 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/dwconv_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/dwconv_int8_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::cmsis {
 class DWConvInt8Coder final : public Conv2DBaseCoder {
  public:
   DWConvInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~DWConvInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/fullconnection_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/fullconnection_int8_coder.h
index e0370dc4d70bcbef39e65687d93cde002b4fb616..afd5254c6cd1995d373cd629e4c5f7ff7e7cc690 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/fullconnection_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/fullconnection_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::cmsis {
 class FullConnectionInt8Coder final : public FullConnectionBaseCoder {
  public:
   FullConnectionInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                          const Model::Node *node, size_t node_index, Target target)
+                          const LiteGraph::Node *node, size_t node_index, Target target)
       : FullConnectionBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/mul_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/mul_int8_coder.h
index 5e9f8cd41e728394af6c954394091e0ea96a23d0..f6a59f00a29f8df56685ea91f2806bb5874f3592 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/mul_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/mul_int8_coder.h
@@ -24,7 +24,7 @@ namespace mindspore::lite::micro::cmsis {
 class MulInt8Coder final : public OperatorCoder {
  public:
   MulInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-               const Model::Node *node, size_t node_index, Target target)
+               const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~MulInt8Coder() override = default;
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/pooling_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/pooling_int8_coder.h
index f955cb0358e73bd4c64f66806a99e0b92d6d4a54..6890d0d766db97cdeae2365d93735b6aed51ef7e 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/pooling_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/pooling_int8_coder.h
@@ -28,7 +28,7 @@ namespace mindspore::lite::micro::cmsis {
 class PoolingInt8Coder final : public OperatorCoder {
  public:
   PoolingInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~PoolingInt8Coder() override = default;
 
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/reshape_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/reshape_int8_coder.h
index 714daf2a9f6cc3c8ee297180078e79ad9ecc2088..68ab9c07275f6ff1c9ff20a7b8561966a25e2a29 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/reshape_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/reshape_int8_coder.h
@@ -24,7 +24,7 @@ namespace mindspore::lite::micro::cmsis {
 class ReshapeInt8Coder final : public OperatorCoder {
  public:
   ReshapeInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReshapeInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/softmax_int8_coder.h b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/softmax_int8_coder.h
index c9e502c75381f260054f6ac62eb4124af96b9ad6..bb774a6cddd4a1cc05d0bbe9cc9933b6c917da4a 100644
--- a/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/softmax_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/cmsis-nn/int8/softmax_int8_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::cmsis {
 class SoftMaxInt8Coder final : public SoftmaxBaseCoder {
  public:
   SoftMaxInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : SoftmaxBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~SoftMaxInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/custom/custom_coder.h b/mindspore/lite/micro/coder/opcoders/custom/custom_coder.h
index 5b2ce86ed940d4ec4e2854c5221f88799b76df2d..0772b55ccdc5b39d646932f3b73aa6a08ef18e1b 100644
--- a/mindspore/lite/micro/coder/opcoders/custom/custom_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/custom/custom_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro {
 class CustomCoder final : public OperatorCoder {
  public:
   CustomCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-              const Model::Node *node, size_t node_index, Target target)
+              const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~CustomCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/activation_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/activation_fp32_coder.h
index ae38c3bca98e519d927f7352935d57c2dd3ed50e..dadd4959da871e9c9a48f79481d17a427e360db7 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/activation_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/activation_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class ActivationFP32Coder final : public OperatorCoder {
  public:
   ActivationFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                      const Model::Node *node, size_t node_index, Target target)
+                      const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ActivationFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/addn_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/addn_fp32_coder.h
index 6441d1c8cfe1e6cfa28ea504d0d4b1218650fb6e..418a1448901745ae4eba024fb1bc4d174195abd5 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/addn_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/addn_fp32_coder.h
@@ -23,7 +23,7 @@ namespace mindspore::lite::micro::nnacl {
 class AddNFP32Coder final : public OperatorCoder {
  public:
   AddNFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                const Model::Node *node, size_t node_index, Target target)
+                const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~AddNFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_fp32_coder.h
index 35ec95050a6cbd1621d2b5a366998ea529253e10..f92ecbed469e879ecd7087bc73cd48255d3fc55a 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_fp32_coder.h
@@ -80,7 +80,7 @@ class ArithmeticFP32Coder final : public OperatorCoder {
 
  public:
   ArithmeticFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                      const Model::Node *node, size_t node_index, Target target)
+                      const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ArithmeticFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_self_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_self_fp32_coder.h
index a60b18deab8f7e7730e3e7b949d1d0859b90816f..cc897b9d165f9c08e365df4ca85a74779c750a9a 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_self_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/arithmetic_self_fp32_coder.h
@@ -92,7 +92,7 @@ using mindspore::schema::PrimitiveType_Erf;
 class ArithmeticSelfFP32Coder final : public OperatorCoder {
  public:
   ArithmeticSelfFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                          const Model::Node *node, size_t node_index, Target target)
+                          const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   int Prepare(CoderContext *const context) override;
   int DoCode(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/assign_add_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/assign_add_fp32_coder.h
index e817e7db2d985ba03b29f54be0f68c8a2c20bfe8..aa897ed82322276254f3f823270b76775b6189b1 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/assign_add_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/assign_add_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class AssignAddFP32Coder final : public OperatorCoder {
  public:
   AssignAddFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                     const Model::Node *node, size_t node_index, Target target)
+                     const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~AssignAddFP32Coder() override = default;
 
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/batchnorm_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/batchnorm_fp32_coder.h
index 5d222c487ff53dc69130e7b9f46258c467f06c3d..4806fa2cbe5e1ef2facd8b7c4f8dbaa4c8c14ee2 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/batchnorm_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/batchnorm_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class BatchnormFP32Coder final : public OperatorCoder {
  public:
   BatchnormFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                     const Model::Node *node, size_t node_index, Target target)
+                     const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~BatchnormFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/biasadd_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/biasadd_fp32_coder.h
index 60064f2af85c35a5eaf9a91dd986fa21e4b8e6d5..f9e3abcffd5db5e7f0750e525b4aa2923a955fe6 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/biasadd_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/biasadd_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class BiasAddFP32Coder final : public OperatorCoder {
  public:
   BiasAddFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~BiasAddFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/concat_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/concat_fp32_coder.h
index 302bb0e5dcb73efcfda94e3a2e23240ce43d5a98..a9567f9bc076f63da125c78155b2ecbceb67e0d1 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/concat_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/concat_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class ConcatFP32Coder final : public OperatorCoder {
  public:
   ConcatFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~ConcatFP32Coder() override = default;
 
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.cc b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.cc
index 3205a5b14359ae58b102b44fbf531b2d6d129b3d..6356d31739e3ecb450a33952b53072937e0d110e 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.cc
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.cc
@@ -63,8 +63,8 @@ void SetInputOutputShapeInfo(ConvParameter *conv_param, const lite::Tensor *inpu
 
 std::unique_ptr<OperatorCoder> CPUConvolutionFP32CoderSelect(const std::vector<Tensor *> &in_tensors,
                                                              const std::vector<Tensor *> &out_tensors,
-                                                             const Model::Node *node, size_t node_index, Target target,
-                                                             int schema_version) {
+                                                             const LiteGraph::Node *node, size_t node_index,
+                                                             Target target, int schema_version) {
   const void *primitive = node->primitive_;
   if (primitive == nullptr) {
     return nullptr;
@@ -101,14 +101,14 @@ std::unique_ptr<OperatorCoder> CPUConvolutionFP32CoderSelect(const std::vector<T
 }
 
 std::unique_ptr<OperatorCoder> CreateDelegateConv(const std::vector<Tensor *> &in_tensors,
-                                                  const std::vector<Tensor *> &out_tensors, const Model::Node *node,
+                                                  const std::vector<Tensor *> &out_tensors, const LiteGraph::Node *node,
                                                   size_t node_index, Target target, int schema_version) {
   return CPUOpCoderCreator<ConvDelegateCoder>(in_tensors, out_tensors, node, node_index, target, schema_version);
 }
 
 std::unique_ptr<OperatorCoder> CPUConvDwFp32CoderCreator(const std::vector<Tensor *> &in_tensors,
                                                          const std::vector<Tensor *> &out_tensors,
-                                                         const Model::Node *node, size_t node_index, Target target,
+                                                         const LiteGraph::Node *node, size_t node_index, Target target,
                                                          int schema_version) {
   return CPUOpCoderCreator<ConvolutionDepthwiseFP32Coder>(in_tensors, out_tensors, node, node_index, target,
                                                           schema_version);
@@ -116,7 +116,7 @@ std::unique_ptr<OperatorCoder> CPUConvDwFp32CoderCreator(const std::vector<Tenso
 
 std::unique_ptr<OperatorCoder> CPUConv2DFusionFP32CoderCreator(const std::vector<Tensor *> &in_tensors,
                                                                const std::vector<Tensor *> &out_tensors,
-                                                               const Model::Node *node, size_t node_index,
+                                                               const LiteGraph::Node *node, size_t node_index,
                                                                Target target, int schema_version) {
   const void *primitive = node->primitive_;
   if (primitive == nullptr) {
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.h
index de80050c8b747ebc99412bb2dea2430fb6387be8..401f533a460587164f255eef074949ca367a3229 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/conv2d_delegate_fp32_coder.h
@@ -24,7 +24,7 @@ namespace mindspore::lite::micro::nnacl {
 class ConvDelegateCoder : public OperatorCoder {
  public:
   ConvDelegateCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                    const Model::Node *node, size_t node_index, Target target)
+                    const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ConvDelegateCoder() override = default;
@@ -38,21 +38,21 @@ class ConvDelegateCoder : public OperatorCoder {
 void SetInputOutputShapeInfo(ConvParameter *conv_param, const lite::Tensor *input, const lite::Tensor *output);
 std::unique_ptr<OperatorCoder> CPUConvolutionFP32CoderSelect(const std::vector<Tensor *> &in_tensors,
                                                              const std::vector<Tensor *> &out_tensors,
-                                                             const Model::Node *node, size_t node_index, Target target,
-                                                             int schema_version);
+                                                             const LiteGraph::Node *node, size_t node_index,
+                                                             Target target, int schema_version);
 
 std::unique_ptr<OperatorCoder> CreateDelegateConv(const std::vector<Tensor *> &in_tensors,
-                                                  const std::vector<Tensor *> &out_tensors, const Model::Node *node,
+                                                  const std::vector<Tensor *> &out_tensors, const LiteGraph::Node *node,
                                                   size_t node_index, Target target, int schema_version);
 
 std::unique_ptr<OperatorCoder> CPUConvDwFp32CoderCreator(const std::vector<Tensor *> &in_tensors,
                                                          const std::vector<Tensor *> &out_tensors,
-                                                         const Model::Node *node, size_t node_index, Target target,
+                                                         const LiteGraph::Node *node, size_t node_index, Target target,
                                                          int schema_version);
 
 std::unique_ptr<OperatorCoder> CPUConv2DFusionFP32CoderCreator(const std::vector<Tensor *> &in_tensors,
                                                                const std::vector<Tensor *> &out_tensors,
-                                                               const Model::Node *node, size_t node_index,
+                                                               const LiteGraph::Node *node, size_t node_index,
                                                                Target target, int schema_version);
 
 }  // namespace mindspore::lite::micro::nnacl
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_depthwise_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_depthwise_fp32_coder.h
index f38a25b24ac151677079eba83530cd3f1ce9bb6d..fbc321524fdce39bed2b7ee1bb5c97fe8b908447 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_depthwise_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_depthwise_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class ConvolutionDepthwiseFP32Coder final : public Conv2DBaseCoder {
  public:
   ConvolutionDepthwiseFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                                const Model::Node *node, size_t node_index, Target target)
+                                const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ConvolutionDepthwiseFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_fp32_coder.h
index 42c2ee583b7ff3a5479020837510c3f714b1d185..a3e8bae29f7ca3b4fbbd7ccfd4f00408ebba9dd4 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_fp32_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::nnacl {
 class ConvolutionFP32Coder final : public Conv2DBaseCoder {
  public:
   ConvolutionFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                       const Model::Node *node, size_t node_index, Target target)
+                       const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_winograd_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_winograd_fp32_coder.h
index 1e236ae62211f67cb9975099503c5dab210563fd..a55c0a718c2ff4f7ee40c8d143639658f890f811 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_winograd_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/convolution_winograd_fp32_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::nnacl {
 class ConvolutionWinogradFP32Coder : public Conv2DBaseCoder {
  public:
   ConvolutionWinogradFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                               const Model::Node *node, size_t node_index, Target target, int output_unit)
+                               const LiteGraph::Node *node, size_t node_index, Target target, int output_unit)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target), output_unit_(output_unit) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/deconv2d_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/deconv2d_fp32_coder.h
index 3c3d7e442af364fb96ae5e76ea1d2633df572552..d962df15ab4160ca72ca44aca76b7e9b467d8d47 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/deconv2d_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/deconv2d_fp32_coder.h
@@ -29,7 +29,7 @@ namespace mindspore::lite::micro::nnacl {
 class DeConvolutionFP32Coder final : public Conv2DBaseCoder {
  public:
   DeConvolutionFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                         const Model::Node *node, size_t node_index, Target target)
+                         const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/exp_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/exp_fp32_coder.h
index 85715cc44cd1d1d4f2ca1cc6852475f88117f0bc..b518e271f0a21691d50556761a772691f7d8599f 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/exp_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/exp_fp32_coder.h
@@ -23,7 +23,7 @@ namespace mindspore::lite::micro::nnacl {
 class ExpFP32Coder final : public OperatorCoder {
  public:
   ExpFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-               const Model::Node *node, size_t node_index, Target target)
+               const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ExpFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/full_connection_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/full_connection_fp32_coder.h
index 1f39ecd57a236d503c9a753ba939c91dfbaf07de..d2566a9fdc84711f789d175c0c25d87939433508 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/full_connection_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/full_connection_fp32_coder.h
@@ -28,7 +28,7 @@ namespace mindspore::lite::micro::nnacl {
 class FullConnectionFP32Coder final : public MatMulFP32BaseCoder {
  public:
   FullConnectionFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                          const Model::Node *node, size_t node_index, Target target)
+                          const LiteGraph::Node *node, size_t node_index, Target target)
       : MatMulFP32BaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/gather_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/gather_fp32_coder.h
index 616b14c255399f947f6ca9fb2fffa679481f68f4..357c5687c6afc37db518d897b5d3a9d180d677a3 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/gather_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/gather_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class GatherFP32Coder final : public OperatorCoder {
  public:
   GatherFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~GatherFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/lstm_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/lstm_fp32_coder.h
index 875abf8beac6b8fb25dfdd0622cbde5f6556bd7c..5d7072fc78ac4ce1f7894477a84047835b9d1083 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/lstm_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/lstm_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class LstmFP32Coder final : public OperatorCoder {
  public:
   LstmFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                const Model::Node *node, size_t node_index, Target target)
+                const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~LstmFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_base_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_base_coder.h
index c03c5f3372a55897e10f2ff41fc896189498f100..202bde2198613ae21d8d5fe90e21ae660d59bb4b 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_base_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_base_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class MatMulFP32BaseCoder : public OperatorCoder {
  public:
   MatMulFP32BaseCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                      const Model::Node *node, size_t node_index, Target target)
+                      const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~MatMulFP32BaseCoder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_coder.h
index 79f6f611ee8e8b77af543a6502befcee5e66425d..22979b8510acaf53431f3869b1d5a6e4d5ecf39c 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/matmul_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class MatMulFP32Coder final : public MatMulFP32BaseCoder {
  public:
   MatMulFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : MatMulFP32BaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~MatMulFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pad_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pad_fp32_coder.h
index 19aff1392114c2447c9b12bae1485b616fcabfac..a2e7bc53339535a508421106ce89e94e252fe11f 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pad_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pad_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class PadFP32Coder final : public OperatorCoder {
  public:
   PadFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-               const Model::Node *node, size_t node_index, Target target)
+               const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~PadFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pooling_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pooling_fp32_coder.h
index ae66ea8a0fdeecac6cc48d6c859e810dfecad1dd..29e34ab4300bc3a165eea30982991620ab59aba7 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pooling_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/pooling_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class PoolingFP32Coder final : public OperatorCoder {
  public:
   PoolingFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~PoolingFP32Coder() override = default;
 
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/power_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/power_fp32_coder.h
index 07ccb7f6012abc9d5054be90887924b21ae10acc..4506a5a38756dd3ad7562cf5ae1180668912de59 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/power_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/power_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class PowerFP32Coder final : public OperatorCoder {
  public:
   PowerFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                 const Model::Node *node, size_t node_index, Target target)
+                 const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~PowerFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/reduce_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/reduce_fp32_coder.h
index 7fea26c0e4a29f31baa7ca6b4ae848cdc93848fd..307efb882881a33a06fa52b12514660a014b1be2 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/reduce_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/reduce_fp32_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class ReduceFP32Coder final : public ReduceBaseCoder {
  public:
   ReduceFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : ReduceBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReduceFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/resize_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/resize_fp32_coder.h
index ac1da325d369ddf645e59338727118461a2cf972..583093db2c16ca2a41e3b3e491ea46f64dec2b55 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/resize_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/resize_fp32_coder.h
@@ -31,7 +31,7 @@ namespace mindspore::lite::micro::nnacl {
 class ResizeFP32Coder final : public ResizeBaseCoder {
  public:
   ResizeFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : ResizeBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~ResizeFP32Coder() override { FreeTmpBuffer(); };
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/scale_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/scale_fp32_coder.h
index 8c3bd65e291682eaf863a582709641983108ae60..a9ad5743b721e0f19530b85d82f00f3eabc6d944 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/scale_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/scale_fp32_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class ScaleFP32Coder final : public OperatorCoder {
  public:
   ScaleFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                 const Model::Node *node, size_t node_index, Target target)
+                 const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~ScaleFP32Coder() override = default;
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/softmax_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/softmax_fp32_coder.h
index 322d4d1c515946c26f42d78fd0d92af9ca934bff..136d3f7936efe6fefdef316ca5b2143526f21c8a 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/softmax_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/softmax_fp32_coder.h
@@ -23,7 +23,7 @@ namespace mindspore::lite::micro::nnacl {
 class SoftMaxFP32Coder final : public SoftmaxBaseCoder {
  public:
   SoftMaxFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : SoftmaxBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/splice_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/splice_fp32_coder.h
index a60b58fae6b754e5e15082ba83cc8e3d88008455..f5f09dbca49dceb7b9e91f4ede6e7f3a940d88e6 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/splice_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/splice_fp32_coder.h
@@ -22,7 +22,7 @@ namespace mindspore::lite::micro::nnacl {
 class SpliceFP32Coder final : public OperatorCoder {
  public:
   SpliceFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~SpliceFP32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/tile_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/tile_fp32_coder.h
index 3b370fc3dadec076ace5b60a052481bd4e998c94..19f9b1e6b0e9398c816858794674d1c662133b6e 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/tile_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/tile_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class TileFP32Coder final : public OperatorCoder {
  public:
   TileFP32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                const Model::Node *node, size_t node_index, Target target)
+                const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~TileFP32Coder() override = default;
 
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/transpose_fp32_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/transpose_fp32_coder.h
index 47519700a602d49e91bf806bf1df2d0655754694..5efe7a300a64787d90b0d128691cb8fed1b090c7 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/fp32/transpose_fp32_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/fp32/transpose_fp32_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class TransposeFp32Coder final : public OperatorCoder {
  public:
   TransposeFp32Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                     const Model::Node *node, size_t node_index, Target target)
+                     const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~TransposeFp32Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/activation_int8_coder.cc b/mindspore/lite/micro/coder/opcoders/nnacl/int8/activation_int8_coder.cc
index ef83ef02861e4f8be098b17843129cbb0e357aa4..862d43e1221a77f33c28b33235ebc7b15cca96fc 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/activation_int8_coder.cc
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/activation_int8_coder.cc
@@ -26,8 +26,8 @@ using mindspore::schema::PrimitiveType_Activation;
 namespace mindspore::lite::micro::nnacl {
 std::unique_ptr<OperatorCoder> CPUActivationINT8CoderCreator(const std::vector<Tensor *> &in_tensors,
                                                              const std::vector<Tensor *> &out_tensors,
-                                                             const Model::Node *node, size_t node_index, Target target,
-                                                             int schema_version) {
+                                                             const LiteGraph::Node *node, size_t node_index,
+                                                             Target target, int schema_version) {
   const void *primitive_c = node->primitive_;
   if (primitive_c == nullptr) {
     return nullptr;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/add_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/add_int8_coder.h
index d6c4d6415fde5fae856fced5b20bd4c406b9ffe8..6bb931a3647a1984badeba2e14a6cbf591f10053 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/add_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/add_int8_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class AddInt8Coder final : public OperatorCoder {
  public:
   AddInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-               const Model::Node *node, size_t node_index, Target target)
+               const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~AddInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/batchnorm_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/batchnorm_int8_coder.h
index 0fdd5608249492aa715eaaaa8e684d834cd86ad9..b8137e1703446c47e511304a4a3a72fbf06e42a5 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/batchnorm_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/batchnorm_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class BatchNormInt8Coder final : public OperatorCoder {
  public:
   BatchNormInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                     const Model::Node *node, size_t node_index, Target target)
+                     const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {
     batchnorm_param_ = reinterpret_cast<BatchNormParameter *>(parameter_);
   }
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/concat_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/concat_int8_coder.h
index bc666683e826a1cb8e32aee339b6aa2cbba3b23e..1229e51a5a9e9da157959aa8561c13dcac31e585 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/concat_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/concat_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class ConcatInt8Coder final : public OperatorCoder {
  public:
   ConcatInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ConcatInt8Coder() {
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_1x1_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_1x1_int8_coder.h
index 29185d6273d88dbf1df4adcf424e9194bc54eff1..c5984f27bcb3f93c7c6eca8066beb2a3c7c173f5 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_1x1_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_1x1_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class Conv2D1x1Int8Coder final : public Conv2DBaseCoder {
  public:
   Conv2D1x1Int8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                     const Model::Node *node, size_t node_index, Target target)
+                     const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_3x3_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_3x3_int8_coder.h
index 7bcea0b5f35f7729765fe68fc150159f4fc3a9b1..826e82c903776d2974e8616f0c79e5b3d737089f 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_3x3_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_3x3_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class Conv2D3x3Int8Coder final : public Conv2DBaseCoder {
  public:
   Conv2D3x3Int8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                     const Model::Node *node, size_t node_index, Target target)
+                     const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.cc b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.cc
index 8bdd00e6b36dc1a7def591ec5df3802122517310..447c548d8165f772ba1fabdcc0f5ea57279f7653 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.cc
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.cc
@@ -247,7 +247,7 @@ int Conv2DINT8Coder::DoCode(CoderContext *const context) {
 
 std::unique_ptr<OperatorCoder> CPUConv2DINT8CoderCreator(const std::vector<Tensor *> &in_tensors,
                                                          const std::vector<Tensor *> &out_tensors,
-                                                         const Model::Node *node, size_t node_index, Target target,
+                                                         const LiteGraph::Node *node, size_t node_index, Target target,
                                                          int schema_version) {
   const void *primitive = node->primitive_;
   if (primitive == nullptr) {
@@ -284,7 +284,7 @@ std::unique_ptr<OperatorCoder> CPUConv2DINT8CoderCreator(const std::vector<Tenso
 
 std::unique_ptr<OperatorCoder> CPUConv2DFusionINT8CoderCreator(const std::vector<Tensor *> &in_tensors,
                                                                const std::vector<Tensor *> &out_tensors,
-                                                               const Model::Node *node, size_t node_index,
+                                                               const LiteGraph::Node *node, size_t node_index,
                                                                Target target, int schema_version) {
   const void *primitive = node->primitive_;
   if (primitive == nullptr) {
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.h
index c34ccf670bb7ba3a0b328ed8589d753ead664e8a..dff69d6e4f41b007666d9975a1c106a565587077 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/conv2d_int8_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::nnacl {
 class Conv2DINT8Coder final : public Conv2DBaseCoder {
  public:
   explicit Conv2DINT8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                           const Model::Node *node, size_t node_index, Target target)
+                           const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   int Prepare(CoderContext *const context) override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/convolution_depthwise_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/convolution_depthwise_int8_coder.h
index 08464a462a5f327010a2694de12dcf72e9d53763..1045289f1333088d57f2407808a0a103516379b3 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/convolution_depthwise_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/convolution_depthwise_int8_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro {
 class ConvolutionDepthwiseINT8Coder : public Conv2DBaseCoder {
  public:
   ConvolutionDepthwiseINT8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                                const Model::Node *node, size_t node_index, Target target)
+                                const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ConvolutionDepthwiseINT8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/deconvolution_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/deconvolution_int8_coder.h
index f404e398ad2ba393f5fda17da5d91456b331c003..a25b5d90d828691dfae23d4f04ac2c24957987db 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/deconvolution_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/deconvolution_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class DeconvolutionInt8Coder final : public Conv2DBaseCoder {
  public:
   DeconvolutionInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                         const Model::Node *node, size_t node_index, Target target)
+                         const LiteGraph::Node *node, size_t node_index, Target target)
       : Conv2DBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~DeconvolutionInt8Coder() override { delete matmul_param_; }
 
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/detection_post_process_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/detection_post_process_int8_coder.h
index 97f86a8ba2290f4513bdaceb475b4431a52ad0eb..7ebdf66390b325f3c325ab8851bec41eb51ce677 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/detection_post_process_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/detection_post_process_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class DetectionPostProcessInt8Coder final : public DetectionPostProcessBaseCoder {
  public:
   DetectionPostProcessInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                                const Model::Node *node, size_t node_index, Target target)
+                                const LiteGraph::Node *node, size_t node_index, Target target)
       : DetectionPostProcessBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~DetectionPostProcessInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/div_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/div_int8_coder.h
index ceccad806bf492bb7329ccc675d623028b6260d3..3d01808cfc6e64d52ed10fd6dcde843ed4ed05f1 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/div_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/div_int8_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::nnacl {
 class DivInt8Coder final : public OperatorCoder {
  public:
   DivInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-               const Model::Node *node, size_t node_index, Target target)
+               const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~DivInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/fullconnection_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/fullconnection_int8_coder.h
index dd12382f20faaf17419ed0ea283e4aedd98160a9..18aa387b9de4e9887e702580e9144ce23e35b2ed 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/fullconnection_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/fullconnection_int8_coder.h
@@ -28,7 +28,7 @@ namespace mindspore::lite::micro::nnacl {
 class FullConnectionInt8Coder final : public MatMulBaseInt8Coder {
  public:
   FullConnectionInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                          const Model::Node *node, size_t node_index, Target target)
+                          const LiteGraph::Node *node, size_t node_index, Target target)
       : MatMulBaseInt8Coder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~FullConnectionInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_base_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_base_int8_coder.h
index c893324df38aec656a089bb8623b3c3b473d1c25..6b66d263c1ef6861a9a3ff1d6c04eb23f7e12c30 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_base_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_base_int8_coder.h
@@ -23,7 +23,7 @@ namespace mindspore::lite::micro::nnacl {
 class MatMulBaseInt8Coder : public OperatorCoder {
  public:
   MatMulBaseInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                      const Model::Node *node, size_t node_index, Target target)
+                      const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
   ~MatMulBaseInt8Coder() override;
 
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_int8_coder.h
index 482c86c95f2086b540dd208f2c56e8fbaa4959f4..80ba36c89a33aa118106574284a0f9c73b50873b 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/matmul_int8_coder.h
@@ -25,7 +25,7 @@ namespace mindspore::lite::micro::nnacl {
 class MatMulInt8Coder final : public MatMulBaseInt8Coder {
  public:
   MatMulInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : MatMulBaseInt8Coder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~MatMulInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/pooling_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/pooling_int8_coder.h
index dd068c8468ee00d5b5b48494470361332f366bcf..92455d6a2b66405c3fa921e2030a92c3b71dbfcc 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/pooling_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/pooling_int8_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::nnacl {
 class PoolingInt8Coder final : public OperatorCoder {
  public:
   PoolingInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~PoolingInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/reduce_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/reduce_int8_coder.h
index bd9d05dfb94deb74a1ce2bc17300b153b98f0eae..1e40cb03d8528546dcf76303683cf17eb022ceb9 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/reduce_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/reduce_int8_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::nnacl {
 class ReduceInt8Coder final : public ReduceBaseCoder {
  public:
   ReduceInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : ReduceBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReduceInt8Coder() override {
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/relux_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/relux_int8_coder.h
index f42db86a0377aefc6c314002c33f176fedbd6c5a..b0195105c619082d668d9c2ad36d42f6f0afff1f 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/relux_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/relux_int8_coder.h
@@ -29,7 +29,7 @@ namespace mindspore::lite::micro::nnacl {
 class ReluxInt8Coder : public OperatorCoder {
  public:
   ReluxInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                 const Model::Node *node, size_t node_index, Target target)
+                 const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReluxInt8Coder() override = default;
@@ -48,7 +48,7 @@ class ReluxInt8Coder : public OperatorCoder {
 class ReluInt8Coder final : public ReluxInt8Coder {
  public:
   ReluInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                const Model::Node *node, size_t node_index, Target target)
+                const LiteGraph::Node *node, size_t node_index, Target target)
       : ReluxInt8Coder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReluInt8Coder() override = default;
@@ -64,7 +64,7 @@ class ReluInt8Coder final : public ReluxInt8Coder {
 class Relu6Int8Coder final : public ReluxInt8Coder {
  public:
   Relu6Int8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                 const Model::Node *node, size_t node_index, Target target)
+                 const LiteGraph::Node *node, size_t node_index, Target target)
       : ReluxInt8Coder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~Relu6Int8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/reshape_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/reshape_int8_coder.h
index 4053f4b02b40098741c1ebf0cc5db846bd0b2273..92bd9ff4c90c1d0b0acdc0cf318395964a3a764d 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/reshape_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/reshape_int8_coder.h
@@ -24,7 +24,7 @@ namespace mindspore::lite::micro::nnacl {
 class ReshapeInt8Coder final : public OperatorCoder {
  public:
   ReshapeInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ReshapeInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/resize_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/resize_int8_coder.h
index bb280639b1c78445d7f7e69db2b885e17912a92a..e23b430a5edc851b7676038d468e622af89a0ba9 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/resize_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/resize_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class ResizeInt8Coder final : public ResizeBaseCoder {
  public:
   ResizeInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : ResizeBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~ResizeInt8Coder() override;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/sigmoid_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/sigmoid_int8_coder.h
index f6d015a197057e8d723650297b6c0107eb59f722..86211d04d57486ea274fb032759a21e1f1434b76 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/sigmoid_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/sigmoid_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class SigmodInt8Coder final : public OperatorCoder {
  public:
   SigmodInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                  const Model::Node *node, size_t node_index, Target target)
+                  const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~SigmodInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/softmax_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/softmax_int8_coder.h
index c8ce4974698c2583433d55b194e7a40d5bc5aa3c..7722b5c3d585769f5ab32f37d314e6ed18887d8c 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/softmax_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/softmax_int8_coder.h
@@ -26,7 +26,7 @@ namespace mindspore::lite::micro::nnacl {
 class SoftMaxInt8Coder final : public SoftmaxBaseCoder {
  public:
   SoftMaxInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                   const Model::Node *node, size_t node_index, Target target)
+                   const LiteGraph::Node *node, size_t node_index, Target target)
       : SoftmaxBaseCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~SoftMaxInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/sub_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/sub_int8_coder.h
index fa34895bc575470802e3c300c510c10d3b4cc3f7..5c771452a4f758392ec8ae0becc448d343ac601a 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/sub_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/sub_int8_coder.h
@@ -27,7 +27,7 @@ namespace mindspore::lite::micro::nnacl {
 class SubInt8Coder final : public OperatorCoder {
  public:
   SubInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-               const Model::Node *node, size_t node_index, Target target)
+               const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~SubInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/nnacl/int8/transpose_int8_coder.h b/mindspore/lite/micro/coder/opcoders/nnacl/int8/transpose_int8_coder.h
index e15dac0b7fe680ea843db1b5fe15966f2f2e4430..29c0f49451b1c3d686376d4b2e1ad120bf5cec17 100644
--- a/mindspore/lite/micro/coder/opcoders/nnacl/int8/transpose_int8_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/nnacl/int8/transpose_int8_coder.h
@@ -24,7 +24,7 @@ namespace mindspore::lite::micro::nnacl {
 class TransposeInt8Coder final : public OperatorCoder {
  public:
   TransposeInt8Coder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                     const Model::Node *node, size_t node_index, Target target)
+                     const LiteGraph::Node *node, size_t node_index, Target target)
       : OperatorCoder(in_tensors, out_tensors, node, node_index, target) {}
 
   ~TransposeInt8Coder() override = default;
diff --git a/mindspore/lite/micro/coder/opcoders/op_coder.h b/mindspore/lite/micro/coder/opcoders/op_coder.h
index a3044c7d47500ff94a462d7dfd4221024d7b7e5d..025c20ac39d636e484fffbe383e4c7544076103a 100644
--- a/mindspore/lite/micro/coder/opcoders/op_coder.h
+++ b/mindspore/lite/micro/coder/opcoders/op_coder.h
@@ -36,7 +36,7 @@ constexpr int kPrecision = 19;
 class OperatorCoder {
  public:
   OperatorCoder(const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors,
-                const Model::Node *node, size_t node_index, Target target)
+                const LiteGraph::Node *node, size_t node_index, Target target)
       : input_tensors_(in_tensors),
         output_tensors_(out_tensors),
         target_(target),
@@ -70,7 +70,7 @@ class OperatorCoder {
 
   void set_parameter(OpParameter *parameter);
 
-  const Model::Node *node() const { return this->node_; }
+  const LiteGraph::Node *node() const { return this->node_; }
 
   void AddInitialParameters(Tensor *parameter) { initial_parameters_.push_back(parameter); }
 
@@ -91,7 +91,7 @@ class OperatorCoder {
   std::vector<Tensor *> input_tensors_;
   std::vector<Tensor *> output_tensors_;
   Target target_{kTargetUnknown};
-  const Model::Node *node_{nullptr};
+  const LiteGraph::Node *node_{nullptr};
   Tensor *input_tensor_{nullptr};
   Tensor *output_tensor_{nullptr};
 
@@ -117,7 +117,7 @@ class OperatorCoder {
 // a template func for normal op_coder creator
 template <typename T>
 std::unique_ptr<OperatorCoder> CPUOpCoderCreator(const std::vector<Tensor *> &in_tensors,
-                                                 const std::vector<Tensor *> &out_tensors, const Model::Node *node,
+                                                 const std::vector<Tensor *> &out_tensors, const LiteGraph::Node *node,
                                                  size_t node_index, Target target, int schema_version) {
   if (node == nullptr) {
     MS_LOG(ERROR) << "node is null";
diff --git a/mindspore/lite/micro/coder/opcoders/op_coder_builder.cc b/mindspore/lite/micro/coder/opcoders/op_coder_builder.cc
index 571fbdc739db31e5f7c7e84e9c1ec565281bf78d..6c897f103a9e96a406795be5d9bea67723edf611 100644
--- a/mindspore/lite/micro/coder/opcoders/op_coder_builder.cc
+++ b/mindspore/lite/micro/coder/opcoders/op_coder_builder.cc
@@ -69,7 +69,7 @@ OpCoderBuilder &OpCoderBuilder::outputs(const std::vector<Tensor *> &outputs) {
   return *this;
 }
 
-OpCoderBuilder &OpCoderBuilder::node(const Model::Node *node) {
+OpCoderBuilder &OpCoderBuilder::node(const LiteGraph::Node *node) {
   this->node_ = node;
   return *this;
 }
diff --git a/mindspore/lite/micro/coder/opcoders/op_coder_builder.h b/mindspore/lite/micro/coder/opcoders/op_coder_builder.h
index 2da028a2f78a5ae34727a7fbf115f91a3b89dc03..cd566aeab631f084e0893b1b5b6039651fc0bf96 100644
--- a/mindspore/lite/micro/coder/opcoders/op_coder_builder.h
+++ b/mindspore/lite/micro/coder/opcoders/op_coder_builder.h
@@ -31,7 +31,7 @@ class OpCoderBuilder {
 
   OpCoderBuilder &outputs(const std::vector<Tensor *> &outputs);
 
-  OpCoderBuilder &node(const Model::Node *node);
+  OpCoderBuilder &node(const LiteGraph::Node *node);
 
   OpCoderBuilder &parameter(OpParameter *parameter);
 
@@ -54,7 +54,7 @@ class OpCoderBuilder {
 
   std::vector<Tensor *> outputs_;
 
-  const mindspore::lite::Model::Node *node_ = nullptr;
+  const mindspore::lite::LiteGraph::Node *node_ = nullptr;
 
   OpParameter *parameter_{nullptr};
 
diff --git a/mindspore/lite/micro/coder/opcoders/op_coder_register.h b/mindspore/lite/micro/coder/opcoders/op_coder_register.h
index 19d0c5fd392a6171bd68ab6e1b5f1e2ab946a36a..9b15c344646fad4f8527bede9747ee8d6c464dc4 100644
--- a/mindspore/lite/micro/coder/opcoders/op_coder_register.h
+++ b/mindspore/lite/micro/coder/opcoders/op_coder_register.h
@@ -27,7 +27,7 @@
 namespace mindspore::lite::micro {
 class OperatorCoder;
 using CoderCreatorFunc = std::function<std::unique_ptr<OperatorCoder>(
-  const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors, const Model::Node *node,
+  const std::vector<Tensor *> &in_tensors, const std::vector<Tensor *> &out_tensors, const LiteGraph::Node *node,
   size_t node_index, Target target, int schema_version)>;
 
 class CoderKey {
diff --git a/mindspore/lite/micro/coder/session.cc b/mindspore/lite/micro/coder/session.cc
index 3e4c27ef1671a56cc54d7d5f4c445592c6cdff0b..8c70f9fcc7399d5b0aa88f811854826da7f98e8c 100644
--- a/mindspore/lite/micro/coder/session.cc
+++ b/mindspore/lite/micro/coder/session.cc
@@ -202,7 +202,7 @@ int CoderSession::InitTensorsRef() {
   return RET_OK;
 }
 
-OpParameter *CoderSession::GenParameterAndInfer(const Model::Node *node, const std::vector<lite::Tensor *> &inputs,
+OpParameter *CoderSession::GenParameterAndInfer(const LiteGraph::Node *node, const std::vector<lite::Tensor *> &inputs,
                                                 std::vector<lite::Tensor *> *outputs) const {
   auto primitive = node->primitive_;
   MS_CHECK_PTR_RET_NULL(primitive);
@@ -234,10 +234,10 @@ int CoderSession::CreateOpCoders() {
   Target code_target = config->target();
   CodeMode code_mode = config->code_mode();
   bool support_parallel = config->support_parallel();
-  uint32_t nodes_size = model->all_nodes_.size();
+  uint32_t nodes_size = model->graph_.all_nodes_.size();
   OpCoderBuilder builder;
   for (uint32_t i = 0; i < nodes_size; ++i) {
-    const auto *node = model->all_nodes_.at(i);
+    const auto *node = model->graph_.all_nodes_.at(i);
     if (node == nullptr) {
       MS_LOG(ERROR) << "node is nullptr";
       return RET_ERROR;
diff --git a/mindspore/lite/micro/coder/session.h b/mindspore/lite/micro/coder/session.h
index 2dd8c3b39ba4466bbf08f3c456a0b580876a2918..909d5481b8accd3697f9c345031e133798e6a097 100644
--- a/mindspore/lite/micro/coder/session.h
+++ b/mindspore/lite/micro/coder/session.h
@@ -43,7 +43,7 @@ class CoderSession {
   int GenerateCode();
 
  private:
-  OpParameter *GenParameterAndInfer(const Model::Node *node, const std::vector<lite::Tensor *> &inputs,
+  OpParameter *GenParameterAndInfer(const LiteGraph::Node *node, const std::vector<lite::Tensor *> &inputs,
                                     std::vector<lite::Tensor *> *outputs) const;
   int InitOpcodersInputsAndOutputs();
   int InitTensorsRef();
diff --git a/mindspore/lite/micro/coder/train.cc b/mindspore/lite/micro/coder/train.cc
index 6532285d2e05d97ca6450edebb61e8b359563e69..83c5ed176a1467ca7d6129cde8fc1a8fa1d534d3 100644
--- a/mindspore/lite/micro/coder/train.cc
+++ b/mindspore/lite/micro/coder/train.cc
@@ -68,7 +68,7 @@ int Train::TransformGraphForTrain(CoderContext *context, const std::vector<std::
                                          schema::PrimitiveType_SigmoidCrossEntropyWithLogitsGrad};
   OperatorCoder *loss_op = nullptr;
   for (const auto &opcoder : op_coders) {
-    const Model::Node *node = opcoder->node();
+    const LiteGraph::Node *node = opcoder->node();
     int primitive_type = GetPrimitiveType(node->primitive_, schema_version);
     auto item = std::find(loss_types.begin(), loss_types.end(), primitive_type);
     if (item != loss_types.end()) {
diff --git a/mindspore/lite/src/delegate/nnrt/checker/primitive_check.cc b/mindspore/lite/src/delegate/nnrt/checker/primitive_check.cc
index 8df160ba7ed3d6698cd1aa98c24154d6dbd5b1ca..4e6868c76b15ed5179dd533b6b50c383c3ddd3a8 100644
--- a/mindspore/lite/src/delegate/nnrt/checker/primitive_check.cc
+++ b/mindspore/lite/src/delegate/nnrt/checker/primitive_check.cc
@@ -181,7 +181,6 @@ Status CheckTensorSupported(const schema::Tensor *primitive) {
     }
   }
   return mindspore::kSuccess;
-  ;
 }
 }  // namespace lite
 }  // namespace mindspore
diff --git a/mindspore/lite/src/train/train_export.cc b/mindspore/lite/src/train/train_export.cc
index 7559b45846a14f16e6eb5087e11417c3fa3c946f..ea401c58782b00a1039f7918ca2f7e4c505aaa15 100644
--- a/mindspore/lite/src/train/train_export.cc
+++ b/mindspore/lite/src/train/train_export.cc
@@ -93,7 +93,7 @@ void TrainExport::TagQuantizedNodes() {
     for (auto &node : meta_graph_->nodes) {
       if (node->quantType != schema::QuantType_QUANT_WEIGHT) {
         for (auto t_idx : node->inputIndex) {
-          if ((meta_graph_->allTensors.at(t_idx)->nodeType == NodeType_ValueNode) &&
+          if (((MSNodeType)meta_graph_->allTensors.at(t_idx)->nodeType == MSNodeType::NodeType_ValueNode) &&
               (meta_graph_->allTensors.at(t_idx)->quantParams.size() > 0)) {
             node->quantType = schema::QuantType_QUANT_WEIGHT;
           }
@@ -163,7 +163,8 @@ std::unique_ptr<schema::TensorT> TrainExport::CreateTensor(const mindspore::lite
   tensorT->offset = 0;
   tensorT->dataType = tensor->data_type();
   tensorT->enableHuffmanCode = false;
-  if ((tensorT->nodeType == NodeType_ValueNode) && (scTensor->data() != nullptr) && (scTensor->data()->size() > 0)) {
+  if (((MSNodeType)tensorT->nodeType == MSNodeType::NodeType_ValueNode) && (scTensor->data() != nullptr) &&
+      (scTensor->data()->size() > 0)) {
     if (NeedQuantization(tensor)) {
       QuantTensorData(tensorT.get(), tensor);
     } else {
@@ -174,10 +175,10 @@ std::unique_ptr<schema::TensorT> TrainExport::CreateTensor(const mindspore::lite
   return tensorT;
 }
 
-Model::Node *TrainExport::FindNode(const mindspore::kernel::LiteKernel *kernel, const Model *model) {
-  auto nodes = model->all_nodes_;
+LiteGraph::Node *TrainExport::FindNode(const mindspore::kernel::LiteKernel *kernel, const Model *model) {
+  auto nodes = model->graph_.all_nodes_;
   auto it = std::find_if(nodes.begin(), nodes.end(),
-                         [&kernel](mindspore::lite::Model::Node *n) { return (kernel->name() == n->name_); });
+                         [&kernel](mindspore::lite::LiteGraph::Node *n) { return (kernel->name() == n->name_); });
   if (it == nodes.end()) {
     return nullptr;
   }
@@ -268,7 +269,7 @@ std::unique_ptr<schema::TensorT> TrainExport::CreateTransformConst(size_t last_i
     MS_LOG(ERROR) << "Could not create tensor ";
     return nullptr;
   }
-  tensorT->nodeType = lite::NodeType_ValueNode;
+  tensorT->nodeType = (int)lite::MSNodeType::NodeType_ValueNode;
   tensorT->dataType = TypeId::kNumberTypeInt32;
   tensorT->dims = {kTransformTensorDim};
   tensorT->format = schema::Format_NCHW;
@@ -354,7 +355,7 @@ int TrainExport::ExportNet(const std::vector<mindspore::kernel::LiteKernel *> &k
   int tensor_idx = offset;
   quant_type_ = quant_type;
   if (meta_graph_ == nullptr) {
-    int status = ExportInit(model->name_, model->version_);
+    int status = ExportInit(model->graph_.name_, model->graph_.version_);
     if (status != RET_OK) {
       return status;
     }
@@ -406,7 +407,7 @@ int TrainExport::ExportNet(const std::vector<mindspore::kernel::LiteKernel *> &k
   for (auto id : map_index) {
     size_t pid = id - offset;
     mindspore::lite::Tensor *tensor = tensors.at(pid);
-    schema::Tensor *scTensor = model->all_tensors_.at(pid);
+    schema::Tensor *scTensor = static_cast<schema::Tensor *>(model->graph_.all_tensors_.at(pid));
     auto tensorT = CreateTensor(tensor, scTensor);
     if (tensorT == nullptr) {
       MS_LOG(ERROR) << "error in tensor creation";
@@ -451,7 +452,7 @@ int TrainExport::TopologicalSort() {
   }
   // put all const tensor index into sinked_tensor_idxes
   for (size_t i = 0; i < meta_graph_->allTensors.size(); i++) {
-    if (meta_graph_->allTensors.at(i)->nodeType == NodeType_ValueNode) {
+    if (static_cast<MSNodeType>(meta_graph_->allTensors.at(i)->nodeType) == MSNodeType::NodeType_ValueNode) {
       sinked_tensor_idxes.push_back(i);
     }
   }
diff --git a/mindspore/lite/src/train/train_export.h b/mindspore/lite/src/train/train_export.h
index 477d71a5d5f88cbc2b13eea33050b5edf2f09211..cadb3329b19e074af72dc4f30653e57777bdc340 100644
--- a/mindspore/lite/src/train/train_export.h
+++ b/mindspore/lite/src/train/train_export.h
@@ -60,7 +60,7 @@ class TrainExport {
   bool IsNodeNonDepend(const std::unique_ptr<schema::CNodeT> &node, const std::vector<size_t> &sinked_tensor_idxes);
   int TopologicalSort();
   void PrepareRemap(int offset);
-  Model::Node *FindNode(const mindspore::kernel::LiteKernel *kernel, const Model *model);
+  LiteGraph::Node *FindNode(const mindspore::kernel::LiteKernel *kernel, const Model *model);
   std::unique_ptr<schema::TensorT> CreateTensor(const Tensor *tensor, schema::Tensor *scTensor);
   std::unique_ptr<schema::CNodeT> CreateCNode(const mindspore::kernel::LiteKernel *kernel,
                                               std::vector<uint32_t> inputIndex, std::vector<uint32_t> outputIndex,
diff --git a/mindspore/lite/src/train/train_session.cc b/mindspore/lite/src/train/train_session.cc
index 6aecca175b4f71ffc62f8e1f5a64a8f379c30f6c..be5bf671f045ffb7e8279a83a455228754d32d06 100644
--- a/mindspore/lite/src/train/train_session.cc
+++ b/mindspore/lite/src/train/train_session.cc
@@ -121,7 +121,7 @@ void TrainSession::FreeWorkSpace() {
 }
 
 int TrainSession::InitCallBack() {
-  sched_mix_precision_callback_ = [&](const Model::Node *node) {
+  sched_mix_precision_callback_ = [&](const LiteGraph::Node *node) {
     if (!context_->IsCpuFloat16Enabled()) {
       return false;
     }
@@ -131,7 +131,8 @@ int TrainSession::InitCallBack() {
         MS_LOG(DEBUG) << "Debug: " << node->name_ << " fp32";
         return false;
       }
-      auto is_fp16 = model_->all_tensors_.at(out_tensor_indexs[0])->dataType() == kNumberTypeFloat16;
+      auto is_fp16 = static_cast<schema::Tensor *>(model_->graph_.all_tensors_.at(out_tensor_indexs[0]))->dataType() ==
+                     kNumberTypeFloat16;
       MS_LOG(DEBUG) << "Debug: " << node->name_ << ((is_fp16) ? " fp16" : " fp32");
       return is_fp16;
     }
@@ -142,8 +143,9 @@ int TrainSession::InitCallBack() {
     auto in_size = node->input_indices_.size();
     bool force_fp16 = false;
     for (std::size_t k = 0; k < in_size; k++) {
-      schema::Tensor *tensor = model_->all_tensors_.at(node->input_indices_[k]);
-      if ((tensor->dataType() == kNumberTypeFloat16) && (tensor->nodeType() == NodeType_ValueNode)) {
+      schema::Tensor *tensor = static_cast<schema::Tensor *>(model_->graph_.all_tensors_.at(node->input_indices_[k]));
+      if ((tensor->dataType() == kNumberTypeFloat16) &&
+          (static_cast<MSNodeType>(tensor->nodeType()) == MSNodeType::NodeType_ValueNode)) {
         force_fp16 = true;
         break;
       }
@@ -1012,7 +1014,7 @@ int TrainSession::Export(const std::string &file_name, ModelType model_type, Qua
   bool orig_train_state = IsTrain();
   Eval();
   TrainExport texport(file_name);
-  int status = texport.ExportInit(model_.get()->name_, model_.get()->version_);
+  int status = texport.ExportInit(model_.get()->graph_.name_, model_.get()->graph_.version_);
   if (status != RET_OK) {
     MS_LOG(ERROR) << "cannot init export";
     return status;