!5047 copy primitive

Merge pull request !5047 from lyvette/master

mindspore/lite/src/ops/abs.h

@@ -33,6 +33,26 @@ class Abs : public ArithmeticSelf {
   explicit Abs(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Abs(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateAbs(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Abs, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/activation.h

@@ -35,6 +35,29 @@ class Activation : public PrimitiveC {
   void SetAlpha(float alpha);
 #else
   explicit Activation(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Activation();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateActivation(fbb, attr->type(), attr->alpha());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Activation, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetType() const;
   float GetAlpha() const;

mindspore/lite/src/ops/activation_grad.h

@@ -34,6 +34,29 @@ class ActivationGrad : public PrimitiveC {
   void SetType(int type);
 #else
   explicit ActivationGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_ActivationGrad();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateActivationGrad(fbb, attr->type());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ActivationGrad, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetType() const;
 };

mindspore/lite/src/ops/add.h

@@ -35,6 +35,29 @@ class Add : public Arithmetic {
   void SetActivationType(int activation_type);
 #else
   explicit Add(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Add();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateAdd(fbb, attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Add, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetActivationType() const;
 };

mindspore/lite/src/ops/addn.h

@@ -34,6 +34,29 @@ class AddN : public PrimitiveC {
   void SetN(int n);
 #else
   explicit AddN(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_AddN();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateAddN(fbb, attr->N());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_AddN, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetN() const;

mindspore/lite/src/ops/argmax.h

@@ -38,6 +38,30 @@ class ArgMax : public PrimitiveC {
   void SetAxisType(int axis_type);
 #else
   explicit ArgMax(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_ArgMax();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateArgMax(fbb, attr->axis(), attr->outMaxValue(),
+                                           attr->topK(), attr->keepDims(), attr->axisType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ArgMax, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetAxis() const;

mindspore/lite/src/ops/argmin.h

@@ -38,6 +38,30 @@ class ArgMin : public PrimitiveC {
   void SetAxisType(int axis_type);
 #else
   explicit ArgMin(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_ArgMin();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateArgMin(fbb, attr->axis(), attr->outMaxValue(),
+                                           attr->topK(), attr->keepDims(), attr->axisType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ArgMin, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetAxis() const;

mindspore/lite/src/ops/batch_norm.h

@@ -35,6 +35,26 @@ class BatchNorm : public PrimitiveC {
   void SetEpsilon(float epsilon);
 #else
   explicit BatchNorm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateBatchNorm(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_BatchNorm, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetEpsilon() const;
 };

mindspore/lite/src/ops/batch_to_space.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,38 @@ class BatchToSpace : public PrimitiveC {
   void SetCrops(const std::vector<int> &crops);
 #else
   explicit BatchToSpace(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_BatchToSpace();
+    MS_ASSERT(attr != nullptr);
+
+    auto blockShape = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->blockShape()->size()); i++) {
+      blockShape->push_back(attr->blockShape()->data()[i]);
+    }
+    auto crops = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->crops()->size()); i++) {
+      crops->push_back(attr->crops()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateBatchToSpaceDirect(fbb, blockShape.release(), crops.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_BatchToSpace, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   std::vector<int> GetBlockShape() const;

mindspore/lite/src/ops/bias_add.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class BiasAdd : public PrimitiveC {
   void SetAxis(const std::vector<int> &axis);
 #else
   explicit BiasAdd(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_BiasAdd();
+    MS_ASSERT(attr != nullptr);
+
+    auto axis = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->axis()->size()); i++) {
+      axis->push_back(attr->axis()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateBiasAddDirect(fbb, axis.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_BiasAdd, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int> GetAxis() const;
 };

mindspore/lite/src/ops/bias_grad.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class BiasGrad : public PrimitiveC {
 
 #else
   explicit BiasGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_BiasGrad();
+    MS_ASSERT(attr != nullptr);
+
+    auto axis = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->axis()->size()); i++) {
+      axis->push_back(attr->axis()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateBiasGradDirect(fbb, axis.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_BiasGrad, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int> GetAxis() const;
 };

mindspore/lite/src/ops/bn_grad_input.h

@@ -35,6 +35,29 @@ class BNGradInput : public PrimitiveC {
   void SetChannels(int channels);
 #else
   explicit BNGradInput(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_BNGradInput();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateBNGradInput(fbb, attr->eps(), attr->channels());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_BNGradInput, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetEps() const;
   int GetChannels() const;

mindspore/lite/src/ops/broadcast_to.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class BroadcastTo : public PrimitiveC {
 
 #else
   explicit BroadcastTo(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_BroadcastTo();
+    MS_ASSERT(attr != nullptr);
+
+    auto dst_shape = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->dst_shape()->size()); i++) {
+      dst_shape->push_back(attr->dst_shape()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateBroadcastToDirect(fbb, dst_shape.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_BroadcastTo, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   std::vector<int> GetDstShape() const;

mindspore/lite/src/ops/caffe_p_relu.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/activation.h"
 
@@ -35,6 +36,34 @@ class CaffePReLU : public Activation {
 
 #else
   explicit CaffePReLU(schema::Primitive *primitive) : Activation(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_CaffePReLU();
+    MS_ASSERT(attr != nullptr);
+
+    auto slope = std::make_unique<std::vector<float>>();
+    for (int i = 0; i < static_cast<int>(attr->slope()->size()); i++) {
+      slope->push_back(attr->slope()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateCaffePReLUDirect(fbb, attr->channelShared(), slope.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_CaffePReLU, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   bool GetChannelShared() const;
 };

mindspore/lite/src/ops/cast.h

@@ -35,6 +35,29 @@ class Cast : public PrimitiveC {
   void SetDstT(int dst_t);
 #else
   explicit Cast(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Cast();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateCast(fbb, attr->srcT(), attr->dstT());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Cast, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetSrcT() const;

mindspore/lite/src/ops/ceil.h

@@ -33,6 +33,26 @@ class Ceil : public ArithmeticSelf {
   explicit Ceil(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Ceil(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateCeil(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Ceil, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/clip.h

@@ -35,6 +35,29 @@ class Clip : public PrimitiveC {
   void SetMin(float min);
 #else
   explicit Clip(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Clip();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateClip(fbb, attr->max(), attr->min());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Clip, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetMax() const;
   float GetMin() const;

mindspore/lite/src/ops/concat.h

@@ -36,6 +36,29 @@ class Concat : public PrimitiveC {
   void SetN(int n);
 #else
   explicit Concat(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Concat();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateConcat(fbb, attr->axis(), attr->n());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Concat, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetAxis() const;

mindspore/lite/src/ops/constant_of_shape.h

@@ -34,6 +34,29 @@ class ConstantOfShape : public PrimitiveC {
   void SetValue(float value);
 #else
   explicit ConstantOfShape(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_ConstantOfShape();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateConstantOfShape(fbb, attr->value());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ConstantOfShape, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   float GetValue() const;

mindspore/lite/src/ops/conv2d.h

@@ -64,6 +64,33 @@ class Conv2D : public PrimitiveC {
 
  public:
   explicit Conv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Conv2D();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateConv2D(fbb, attr->format(), attr->group(), attr->channelIn(), attr->channelOut(),
+                                           attr->kernelW(), attr->kernelH(), attr->strideW(), attr->strideH(),
+                                           attr->padMode(), attr->padUp(), attr->padDown(), attr->padLeft(),
+                                           attr->padRight(), attr->dilateW(), attr->dilateH(),
+                                           attr->hasBias(), attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Conv2D, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 
  public:

mindspore/lite/src/ops/conv2d_grad_filter.h

@@ -50,6 +50,34 @@ class Conv2DGradFilter : public PrimitiveC {
   void SetActivationType(int activation_type);
 #else
   explicit Conv2DGradFilter(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Conv2DGradFilter();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateConv2DGradFilter(fbb, attr->format(), attr->group(),
+                                                     attr->channelIn(), attr->channelOut(),
+                                                     attr->kernelW(), attr->kernelH(), attr->strideW(), attr->strideH(),
+                                                     attr->padMode(), attr->padUp(), attr->padDown(), attr->padLeft(),
+                                                     attr->padRight(), attr->dilateW(), attr->dilateH(),
+                                                     attr->hasBias(), attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Conv2DGradFilter, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetFormat() const;
   int GetGroup() const;

mindspore/lite/src/ops/conv2d_grad_input.h

@@ -50,6 +50,34 @@ class Conv2DGradInput : public PrimitiveC {
   void SetActivationType(int activation_type);
 #else
   explicit Conv2DGradInput(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Conv2DGradInput();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateConv2DGradInput(fbb, attr->format(), attr->group(),
+                                                    attr->channelIn(), attr->channelOut(),
+                                                    attr->kernelW(), attr->kernelH(), attr->strideW(), attr->strideH(),
+                                                    attr->padMode(), attr->padUp(), attr->padDown(), attr->padLeft(),
+                                                    attr->padRight(), attr->dilateW(), attr->dilateH(),
+                                                    attr->hasBias(), attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Conv2DGradInput, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetFormat() const;
   int GetGroup() const;

mindspore/lite/src/ops/cos.h

@@ -32,6 +32,26 @@ class Cos : public ArithmeticSelf {
   explicit Cos(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Cos(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateCos(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Cos, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/crop.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class Crop : public PrimitiveC {
   void SetOffsets(const std::vector<int64_t> &offsets);
 #else
   explicit Crop(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Crop();
+    MS_ASSERT(attr != nullptr);
+
+    auto offsets = std::make_unique<std::vector<int64_t>>();
+    for (int i = 0; i < static_cast<int>(attr->offsets()->size()); i++) {
+      offsets->push_back(attr->offsets()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateCropDirect(fbb, attr->axis(), offsets.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Crop, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int64_t GetAxis() const;

mindspore/lite/src/ops/deconv2d.h

@@ -50,6 +50,33 @@ class DeConv2D : public PrimitiveC {
   void SetActivationType(int activation_type);
 #else
   explicit DeConv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_DeConv2D();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateDeConv2D(fbb, attr->format(), attr->group(), attr->channelIn(), attr->channelOut(),
+                                             attr->kernelW(), attr->kernelH(), attr->strideW(), attr->strideH(),
+                                             attr->padMode(), attr->padUp(), attr->padDown(), attr->padLeft(),
+                                             attr->padRight(), attr->dilateW(), attr->dilateH(),
+                                             attr->hasBias(), attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_DeConv2D, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetFormat() const;

mindspore/lite/src/ops/dedepthwise_conv2d.h

@@ -49,6 +49,33 @@ class DeDepthwiseConv2D : public PrimitiveC {
   void SetActivationType(int activation_type);
 #else
   explicit DeDepthwiseConv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_DeDepthwiseConv2D();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateDeDepthwiseConv2D(fbb, attr->format(), attr->channelIn(), attr->channelMultiplier(),
+                                             attr->kernelW(), attr->kernelH(), attr->strideW(), attr->strideH(),
+                                             attr->padMode(), attr->padUp(), attr->padDown(), attr->padLeft(),
+                                             attr->padRight(), attr->dilateW(), attr->dilateH(),
+                                             attr->hasBias(), attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_DeDepthwiseConv2D, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetFormat() const;

mindspore/lite/src/ops/depth_to_space.h

@@ -35,6 +35,29 @@ class DepthToSpace : public PrimitiveC {
   void SetFormat(int format);
 #else
   explicit DepthToSpace(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_DepthToSpace();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateDepthToSpace(fbb, attr->blockSize(), attr->format());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_DepthToSpace, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetBlockSize() const;

mindspore/lite/src/ops/depthwise_conv2d.h

@@ -59,6 +59,34 @@ class DepthwiseConv2D : public PrimitiveC {
 
  public:
   explicit DepthwiseConv2D(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_DepthwiseConv2D();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateDepthwiseConv2D(fbb, attr->format(),
+                                                    attr->channelIn(), attr->channelMultiplier(),
+                                                    attr->kernelW(), attr->kernelH(), attr->strideW(), attr->strideH(),
+                                                    attr->padMode(), attr->padUp(), attr->padDown(), attr->padLeft(),
+                                                    attr->padRight(), attr->dilateW(), attr->dilateH(),
+                                                    attr->hasBias(), attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_DepthwiseConv2D, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 
  public:

mindspore/lite/src/ops/detection_post_process.h

@@ -46,6 +46,35 @@ class DetectionPostProcess : public PrimitiveC {
   void SetUseRegularNms(bool use_regular_nms);
 #else
   explicit DetectionPostProcess(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_DetectionPostProcess();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateDetectionPostProcess(fbb, attr->format(), attr->inputSize(),
+                                                         attr->hScale(), attr->wScale(),
+                                                         attr->xScale(), attr->yScale(),
+                                                         attr->NmsIouThreshold(), attr->NmsScoreThreshold(),
+                                                         attr->MaxDetections(), attr->DetectionsPreClass(),
+                                                         attr->MaxClassesPreDetection(), attr->NumClasses(),
+                                                         attr->UseRegularNms());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_DetectionPostProcess, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetFormat() const;
   int GetInputSize() const;

mindspore/lite/src/ops/div.h

@@ -35,6 +35,29 @@ class Div : public Arithmetic {
 
 #else
   explicit Div(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Div();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateDiv(fbb, attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Div, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetActivationType() const;
 };

mindspore/lite/src/ops/dropout.h

@@ -35,6 +35,29 @@ class Dropout : public PrimitiveC {
 
 #else
   explicit Dropout(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Dropout();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateDropout(fbb, attr->ratio());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Dropout, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetRatio() const;
 };

mindspore/lite/src/ops/eltwise.h

@@ -35,6 +35,29 @@ class Eltwise : public PrimitiveC {
 
 #else
   explicit Eltwise(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Eltwise();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateEltwise(fbb, attr->mode());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Eltwise, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetMode() const;
 };

mindspore/lite/src/ops/elu.h

@@ -35,6 +35,29 @@ class Elu : public PrimitiveC {
 
 #else
   explicit Elu(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Elu();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateElu(fbb, attr->alpha());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Elu, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetAlpha() const;
 };

mindspore/lite/src/ops/embedding_lookup.h

@@ -35,6 +35,29 @@ class EmbeddingLookup : public PrimitiveC {
 
 #else
   explicit EmbeddingLookup(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_EmbeddingLookup();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateEmbeddingLookup(fbb, attr->maxNorm());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_EmbeddingLookup, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   float GetMaxNorm() const;

mindspore/lite/src/ops/embedding_lookup_sparse.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -36,6 +37,38 @@ class EmbeddingLookupSparse : public PrimitiveC {
   void SetMaxNortm(float max_nortm);
 #else
   explicit EmbeddingLookupSparse(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_EmbeddingLookupSparse();
+    MS_ASSERT(attr != nullptr);
+
+    auto spIds = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->spIds()->size()); i++) {
+      spIds->push_back(attr->spIds()->data()[i]);
+    }
+    auto spWeights = std::make_unique<std::vector<float>>();
+    for (int i = 0; i < static_cast<int>(attr->spWeights()->size()); i++) {
+      spWeights->push_back(attr->spWeights()->data()[i]);
+    }
+
+    auto val_offset = schema:: CreateEmbeddingLookupSparseDirect(fbb, spIds.release(), spWeights.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_EmbeddingLookupSparse, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int> GetSpIds() const;
   std::vector<float> GetSpWeights() const;

mindspore/lite/src/ops/equal.h

@@ -33,6 +33,26 @@ class Equal : public Arithmetic {
   explicit Equal(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit Equal(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateEqual(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Equal, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/exp.h

@@ -33,6 +33,26 @@ class Exp : public ArithmeticSelf {
   explicit Exp(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Exp(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateExp(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Exp, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/expand_dims.h

@@ -35,6 +35,29 @@ class ExpandDims : public PrimitiveC {
 
 #else
   explicit ExpandDims(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_ExpandDims();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateExpandDims(fbb, attr->dim());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ExpandDims, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetDim() const;

mindspore/lite/src/ops/fake_quant_with_min_max_vars.h

@@ -35,6 +35,30 @@ class FakeQuantWithMinMaxVars : public PrimitiveC {
   void SetNumBits(int num_bits);
 #else
   explicit FakeQuantWithMinMaxVars(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_FakeQuantWithMinMaxVars();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateFakeQuantWithMinMaxVars(fbb, attr->narrowRange(), attr->numBits());
+    auto prim_offset = schema::CreatePrimitive(fbb,
+                                               schema::PrimitiveType_FakeQuantWithMinMaxVars, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   bool GetNarrowRange() const;
   int GetNumBits() const;

mindspore/lite/src/ops/fill.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class Fill : public PrimitiveC {
 
 #else
   explicit Fill(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Fill();
+    MS_ASSERT(attr != nullptr);
+
+    auto dims = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->dims()->size()); i++) {
+      dims->push_back(attr->dims()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateFillDirect(fbb, dims.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Fill, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   std::vector<int> GetDims() const;

mindspore/lite/src/ops/flatten.h

@@ -33,6 +33,26 @@ class Flatten : public PrimitiveC {
   explicit Flatten(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   explicit Flatten(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateFlatten(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Flatten, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
 

mindspore/lite/src/ops/floor.h

@@ -33,6 +33,26 @@ class Floor : public ArithmeticSelf {
   explicit Floor(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Floor(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateFloor(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Floor, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/floor_div.h

@@ -33,6 +33,26 @@ class FloorDiv : public Arithmetic {
   explicit FloorDiv(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit FloorDiv(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateFloorDiv(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_FloorDiv, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/floor_mod.h

@@ -33,6 +33,26 @@ class FloorMod : public Arithmetic {
   explicit FloorMod(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit FloorMod(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateFloorMod(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_FloorMod, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/full_connection.h

@@ -37,6 +37,30 @@ class FullConnection : public PrimitiveC {
   void SetActivationType(int activationType);
 #else
   explicit FullConnection(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_FullConnection();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateFullConnection(fbb, attr->hasBias(), attr->axis(),
+                                                   attr->useAxis(), attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_FullConnection, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   bool GetHasBias() const;

mindspore/lite/src/ops/fused_batchnorm.h

@@ -36,6 +36,29 @@ class FusedBatchNorm : public PrimitiveC {
   void SetSpatial(int spatial);
 #else
   explicit FusedBatchNorm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_FusedBatchNorm();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateFusedBatchNorm(fbb, attr->epsilon(), attr->momentum(), attr->spatial());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_FusedBatchNorm, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetEpsilon() const;
   float GetMomentum() const;

mindspore/lite/src/ops/gather.h

@@ -35,6 +35,29 @@ class Gather : public PrimitiveC {
   void SetBatchDims(int batch_dims);
 #else
   explicit Gather(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Gather();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateGather(fbb, attr->axis(), attr->batchDims());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Gather, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetAxis() const;

mindspore/lite/src/ops/gather_nd.h

@@ -35,6 +35,29 @@ class GatherNd : public PrimitiveC {
 
 #else
   explicit GatherNd(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_GatherNd();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateGatherNd(fbb, attr->batchDims());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_GatherNd, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetBatchDims() const;

mindspore/lite/src/ops/greater.h

@@ -32,6 +32,26 @@ class Greater : public Arithmetic {
   explicit Greater(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit Greater(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateGreater(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Greater, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/greater_equal.h

@@ -33,6 +33,26 @@ class GreaterEqual : public Arithmetic {
   explicit GreaterEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit GreaterEqual(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateGreaterEqual(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_GreaterEqual, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/l2_norm.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class L2Norm : public PrimitiveC {
   void SetEpsilon(float epsilon);
 #else
   explicit L2Norm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_L2Norm();
+    MS_ASSERT(attr != nullptr);
+
+    auto axis = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->axis()->size()); i++) {
+      axis->push_back(attr->axis()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateL2NormDirect(fbb, axis.release(), attr->epsilon());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_L2Norm, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int> GetAxis() const;
   float GetEpsilon() const;

mindspore/lite/src/ops/leaky_relu.h

@@ -35,6 +35,29 @@ class LeakyReLU : public PrimitiveC {
 
 #else
   explicit LeakyReLU(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_LeakyReLU();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateLeakyReLU(fbb, attr->negativeSlope());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_LeakyReLU, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetNegativeSlope() const;
 };

mindspore/lite/src/ops/less.h

@@ -33,6 +33,26 @@ class Less : public Arithmetic {
   explicit Less(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit Less(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateLess(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Less, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/less_equal.h

@@ -33,6 +33,26 @@ class LessEqual : public Arithmetic {
   explicit LessEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit LessEqual(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateLessEqual(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_LessEqual, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/local_response_normalization.h

@@ -37,6 +37,30 @@ class LocalResponseNormalization : public PrimitiveC {
   void SetBeta(float beta);
 #else
   explicit LocalResponseNormalization(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_LocalResponseNormalization();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateLocalResponseNormalization(fbb, attr->depth_radius(), attr->bias(),
+                                                               attr->alpha(), attr->beta());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_LocalResponseNormalization, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetDepthRadius() const;
   float GetBias() const;

mindspore/lite/src/ops/log.h

@@ -33,6 +33,26 @@ class Log : public ArithmeticSelf {
   explicit Log(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Log(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateLog(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Log, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/logical_and.h

@@ -33,6 +33,26 @@ class LogicalAnd : public Arithmetic {
   explicit LogicalAnd(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit LogicalAnd(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateLogicalAnd(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_LogicalAnd, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/logical_not.h

@@ -33,6 +33,26 @@ class LogicalNot : public ArithmeticSelf {
   explicit LogicalNot(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit LogicalNot(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateLogicalNot(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_LogicalNot, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/logical_or.h

@@ -33,6 +33,26 @@ class LogicalOr : public Arithmetic {
   explicit LogicalOr(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit LogicalOr(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateLogicalOr(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_LogicalOr, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/lrn.h

@@ -37,6 +37,29 @@ class Lrn : public PrimitiveC {
   void SetSize(int size);
 #else
   explicit Lrn(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Lrn();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateLrn(fbb, attr->alpha(), attr->beta(), attr->bias(), attr->size());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Lrn, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetAlpha() const;
   float GetBeta() const;

mindspore/lite/src/ops/lstm.h

@@ -35,6 +35,29 @@ class Lstm : public PrimitiveC {
 
 #else
   explicit Lstm(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Lstm();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateLstm(fbb, attr->bidirection());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Lstm, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   bool GetBidirection() const;

mindspore/lite/src/ops/make_tuple.h

@@ -30,6 +30,26 @@ class MakeTuple : public PrimitiveC {
   int UnPackAttr(const Primitive &prim, const std::vector<AnfNodePtr> &inputs);
 #else
   explicit MakeTuple(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateMakeTuple(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_MakeTuple, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/matmul.h

@@ -44,6 +44,29 @@ class MatMul : public PrimitiveC {
 
  public:
   explicit MatMul(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_MatMul();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateMatMul(fbb, attr->transposeA(), attr->transposeB());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_MatMul, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 
  public:

mindspore/lite/src/ops/matrix_diag.h

@@ -37,6 +37,30 @@ class MatrixDiag : public PrimitiveC {
   void SetPaddingValue(float padding_value);
 #else
   explicit MatrixDiag(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_MatrixDiag();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateMatrixDiag(fbb, attr->k(), attr->numRows(),
+                                               attr->numCols(), attr->paddingValue());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_MatrixDiag, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetK() const;
   int GetNumRows() const;

mindspore/lite/src/ops/maximum.h

@@ -33,6 +33,26 @@ class Maximum : public Arithmetic {
   explicit Maximum(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit Maximum(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateMaximum(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Maximum, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/mean.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class Mean : public PrimitiveC {
   void SetKeepDims(bool keep_dims);
 #else
   explicit Mean(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Mean();
+    MS_ASSERT(attr != nullptr);
+
+    auto axis = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->axis()->size()); i++) {
+      axis->push_back(attr->axis()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateMeanDirect(fbb, axis.release(), attr->keepDims());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Mean, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   std::vector<int> GetAxis() const;

mindspore/lite/src/ops/minimum.h

@@ -33,6 +33,26 @@ class Minimum : public Arithmetic {
   explicit Minimum(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit Minimum(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateMinimum(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Minimum, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/mul.h

@@ -35,6 +35,29 @@ class Mul : public Arithmetic {
 
 #else
   explicit Mul(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Mul();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateMul(fbb, attr->activationType());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Mul, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetActivationType() const;
 

mindspore/lite/src/ops/nchw2nhwc.h

@@ -33,6 +33,26 @@ class Nchw2Nhwc : public PrimitiveC {
   explicit Nchw2Nhwc(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   explicit Nchw2Nhwc(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateNchw2Nhwc(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Nchw2Nhwc, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
 };

mindspore/lite/src/ops/nhwc2nchw.h

@@ -33,6 +33,26 @@ class Nhwc2Nchw : public PrimitiveC {
   explicit Nhwc2Nchw(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   explicit Nhwc2Nchw(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateNhwc2Nchw(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Nhwc2Nchw, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
 };

mindspore/lite/src/ops/not_equal.h

@@ -33,6 +33,26 @@ class NotEqual : public Arithmetic {
   explicit NotEqual(schema::PrimitiveT *primitive) : Arithmetic(primitive) {}
 #else
   explicit NotEqual(schema::Primitive *primitive) : Arithmetic(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateNotEqual(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_NotEqual, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/one_hot.h

@@ -35,6 +35,29 @@ class OneHot : public PrimitiveC {
 
 #else
   explicit OneHot(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_OneHot();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateOneHot(fbb, attr->axis());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_OneHot, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetAxis() const;

mindspore/lite/src/ops/pad.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -36,6 +37,34 @@ class Pad : public PrimitiveC {
   void SetConstantValue(float constant_value);
 #else
   explicit Pad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Pad();
+    MS_ASSERT(attr != nullptr);
+
+    auto paddings = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->paddings()->size()); i++) {
+      paddings->push_back(attr->paddings()->data()[i]);
+    }
+
+    auto val_offset = schema::CreatePadDirect(fbb, paddings.release(), attr->paddingMode(), attr->constantValue());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Pad, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   std::vector<int> GetPaddings() const;

mindspore/lite/src/ops/permute.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -32,6 +33,34 @@ class Permute : public PrimitiveC {
   explicit Permute(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   explicit Permute(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Permute();
+    MS_ASSERT(attr != nullptr);
+
+    auto order = std::make_unique<std::vector<int64_t>>();
+    for (int i = 0; i < static_cast<int>(attr->order()->size()); i++) {
+      order->push_back(attr->order()->data()[i]);
+    }
+
+    auto val_offset = schema::CreatePermuteDirect(fbb, order.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Permute, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int64_t> GetOrder() const;
   void SetOrder(const std::vector<int64_t> &order);

mindspore/lite/src/ops/pooling.h

@@ -47,6 +47,32 @@ class Pooling : public PrimitiveC {
   void SetActivationType(int activation_type);
 #else
   explicit Pooling(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Pooling();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreatePooling(fbb, attr->format(), attr->poolingMode(), attr->global(),
+                                            attr->windowW(), attr->windowH(), attr->strideW(), attr->strideH(),
+                                            attr->padMode(), attr->padUp(), attr->padDown(),
+                                            attr->padLeft(), attr->padRight(), attr->roundMode());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Pooling, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetFormat() const;

mindspore/lite/src/ops/pooling_grad.h

@@ -46,6 +46,32 @@ class PoolingGrad : public PrimitiveC {
   void SetRoundMode(int round_mode);
 #else
   explicit PoolingGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_PoolingGrad();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreatePoolingGrad(fbb, attr->format(), attr->poolingMode(), attr->global(),
+                                                attr->windowW(), attr->windowH(), attr->strideW(), attr->strideH(),
+                                                attr->padMode(), attr->padUp(), attr->padDown(),
+                                                attr->padLeft(), attr->padRight(), attr->roundMode());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_PoolingGrad, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetFormat() const;
   int GetPoolingMode() const;

mindspore/lite/src/ops/power.h

@@ -36,6 +36,29 @@ class Power : public PrimitiveC {
   void SetShift(float shift);
 #else
   explicit Power(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Power();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreatePower(fbb, attr->power(), attr->scale(), attr->shift());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Power, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   float GetPower() const;

mindspore/lite/src/ops/power_grad.h

@@ -36,6 +36,29 @@ class PowerGrad : public PrimitiveC {
   void SetShift(float shift);
 #else
   explicit PowerGrad(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_PowerGrad();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreatePowerGrad(fbb, attr->power(), attr->scale(), attr->shift());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_PowerGrad, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   float GetPower() const;
   float GetScale() const;

mindspore/lite/src/ops/prelu.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/activation.h"
 
@@ -35,6 +36,34 @@ class Prelu : public Activation {
 
 #else
   explicit Prelu(schema::Primitive *primitive) : Activation(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Prelu();
+    MS_ASSERT(attr != nullptr);
+
+    auto slope = std::make_unique<std::vector<float>>();
+    for (int i = 0; i < static_cast<int>(attr->slope()->size()); i++) {
+      slope->push_back(attr->slope()->data()[i]);
+    }
+
+    auto val_offset = schema::CreatePreluDirect(fbb, slope.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Prelu, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<float> GetSlope() const;
 };

mindspore/lite/src/ops/prior_box.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -44,6 +45,47 @@ class PriorBox : public PrimitiveC {
   void SetOffset(float offset);
 #else
   explicit PriorBox(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_PriorBox();
+    MS_ASSERT(attr != nullptr);
+
+    auto min_sizes = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->min_sizes()->size()); i++) {
+      min_sizes->push_back(attr->min_sizes()->data()[i]);
+    }
+    auto max_sizes = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->max_sizes()->size()); i++) {
+      max_sizes->push_back(attr->max_sizes()->data()[i]);
+    }
+    auto aspect_ratios = std::make_unique<std::vector<float>>();
+    for (int i = 0; i < static_cast<int>(attr->aspect_ratios()->size()); i++) {
+      aspect_ratios->push_back(attr->aspect_ratios()->data()[i]);
+    }
+    auto variances = std::make_unique<std::vector<float>>();
+    for (int i = 0; i < static_cast<int>(attr->variances()->size()); i++) {
+      variances->push_back(attr->variances()->data()[i]);
+    }
+
+    auto val_offset = schema::CreatePriorBoxDirect(fbb, min_sizes.release(), max_sizes.release(),
+                                                   aspect_ratios.release(), variances.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_PriorBox, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   std::vector<int> GetMinSizes() const;

mindspore/lite/src/ops/quant_dtype_cast.h

@@ -35,6 +35,29 @@ class QuantDTypeCast : public PrimitiveC {
   void SetDstT(int dst_t);
 #else
   explicit QuantDTypeCast(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_QuantDTypeCast();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateQuantDTypeCast(fbb, attr->srcT(), attr->dstT());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_QuantDTypeCast, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetSrcT() const;

mindspore/lite/src/ops/range.h

@@ -37,6 +37,29 @@ class Range : public PrimitiveC {
   void SetDelta(int delta);
 #else
   explicit Range(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Range();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateRange(fbb, attr->dType(), attr->start(), attr->limit(), attr->delta());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Range, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetDType() const;

mindspore/lite/src/ops/rank.h

@@ -33,6 +33,26 @@ class Rank : public PrimitiveC {
   explicit Rank(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   explicit Rank(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateRank(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Rank, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
 };

mindspore/lite/src/ops/reduce.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -37,6 +38,34 @@ class Reduce : public PrimitiveC {
   void SetMode(int mode);
 #else
   explicit Reduce(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Reduce();
+    MS_ASSERT(attr != nullptr);
+
+    auto axes = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->axes()->size()); i++) {
+      axes->push_back(attr->axes()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateReduceDirect(fbb, axes.release(), attr->keepDims(), attr->mode());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Reduce, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   std::vector<int> GetAxes() const;

mindspore/lite/src/ops/reshape.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -36,6 +37,34 @@ class Reshape : public PrimitiveC {
   void SetShape(const std::vector<int64_t> &shape);
 #else
   explicit Reshape(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Reshape();
+    MS_ASSERT(attr != nullptr);
+
+    auto shape = std::make_unique<std::vector<int64_t>>();
+    for (int i = 0; i < static_cast<int>(attr->shape()->size()); i++) {
+      shape->push_back(attr->shape()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateReshapeDirect(fbb, attr->format(), shape.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Reshape, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetFormat() const;

mindspore/lite/src/ops/resize.h

@@ -39,6 +39,31 @@ class Resize : public PrimitiveC {
   void SetPreserveAspectRatio(bool preserve_aspect_ratio);
 #else
   explicit Resize(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Resize();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateResize(fbb, attr->format(), attr->method(),
+                                           attr->newHeight(), attr->newWidth(),
+                                           attr->alignCorners(), attr->preserveAspectRatio());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Resize, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetFormat() const;

mindspore/lite/src/ops/reverse.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class Reverse : public PrimitiveC {
 
 #else
   explicit Reverse(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Reverse();
+    MS_ASSERT(attr != nullptr);
+
+    auto axis = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->axis()->size()); i++) {
+      axis->push_back(attr->axis()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateReverseDirect(fbb, axis.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Reverse, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int> GetAxis() const;
 };

mindspore/lite/src/ops/reverse_sequence.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -36,6 +37,35 @@ class ReverseSequence : public PrimitiveC {
   void SetSeqLengths(const std::vector<int> &seq_lengths);
 #else
   explicit ReverseSequence(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_ReverseSequence();
+    MS_ASSERT(attr != nullptr);
+
+    auto seqLengths = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->seqLengths()->size()); i++) {
+      seqLengths->push_back(attr->seqLengths()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateReverseSequenceDirect(fbb, attr->seqAxis(),
+                                                          attr->batchAxis(), seqLengths.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ReverseSequence, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetSeqAxis() const;

mindspore/lite/src/ops/roi_pooling.h

@@ -36,6 +36,29 @@ class ROIPooling : public PrimitiveC {
   void SetScale(float scale);
 #else
   explicit ROIPooling(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_ROIPooling();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateROIPooling(fbb, attr->pooledH(), attr->pooledW(), attr->scale());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ROIPooling, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetPooledH() const;

mindspore/lite/src/ops/round.h

@@ -33,6 +33,26 @@ class Round : public ArithmeticSelf {
   explicit Round(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Round(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateRound(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Round, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/rsqrt.h

@@ -33,6 +33,26 @@ class Rsqrt : public ArithmeticSelf {
   explicit Rsqrt(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Rsqrt(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateRsqrt(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Rsqrt, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/scale.h

@@ -35,6 +35,29 @@ class Scale : public PrimitiveC {
 
 #else
   explicit Scale(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Scale();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateScale(fbb, attr->axis());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Scale, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int GetAxis() const;
 };

mindspore/lite/src/ops/scatter_nd.h

@@ -33,6 +33,26 @@ class ScatterND : public PrimitiveC {
   explicit ScatterND(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   explicit ScatterND(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateScatterND(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ScatterND, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
 };

mindspore/lite/src/ops/shape.h

@@ -33,6 +33,26 @@ class Shape : public PrimitiveC {
   explicit Shape(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {}
 #else
   explicit Shape(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateShape(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Shape, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
 };

mindspore/lite/src/ops/sin.h

@@ -33,6 +33,26 @@ class Sin : public ArithmeticSelf {
   explicit Sin(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {}
 #else
   explicit Sin(schema::Primitive *primitive) : ArithmeticSelf(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto val_offset = schema::CreateSin(fbb);
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Sin, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
 };
 }  // namespace lite

mindspore/lite/src/ops/slice.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -36,6 +37,38 @@ class Slice : public PrimitiveC {
   void SetSize(const std::vector<int> &size);
 #else
   explicit Slice(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_Slice();
+    MS_ASSERT(attr != nullptr);
+
+    auto begin = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->begin()->size()); i++) {
+      begin->push_back(attr->begin()->data()[i]);
+    }
+    auto size = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->size()->size()); i++) {
+      size->push_back(attr->size()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateSliceDirect(fbb, attr->format(), begin.release(), size.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Slice, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetFormat() const;
@@ -46,6 +79,7 @@ class Slice : public PrimitiveC {
   // when running graph, we need to obtain new begins and sizes using the two function as below.
   std::vector<int> GetPostProcessBegin() const;
   std::vector<int> GetPostProcessSize() const;
+
  protected:
     std::vector<int> begin = {0};
     std::vector<int> size = {-1};

mindspore/lite/src/ops/softmax.h

@@ -35,6 +35,29 @@ class SoftMax : public PrimitiveC {
 
 #else
   explicit SoftMax(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_SoftMax();
+    MS_ASSERT(attr != nullptr);
+
+    auto val_offset = schema::CreateSoftMax(fbb, attr->axis());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_SoftMax, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs_, std::vector<lite::tensor::Tensor *> outputs_) override;
   int GetAxis() const;

mindspore/lite/src/ops/softmax_cross_entropy.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,34 @@ class SoftmaxCrossEntropy : public PrimitiveC {
 
 #else
   explicit SoftmaxCrossEntropy(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_SoftmaxCrossEntropy();
+    MS_ASSERT(attr != nullptr);
+
+    auto axis = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->axis()->size()); i++) {
+      axis->push_back(attr->axis()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateSoftmaxCrossEntropyDirect(fbb, axis.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_SoftmaxCrossEntropy, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int> GetAxis() const;
 };

mindspore/lite/src/ops/space_to_batch.h

@@ -20,6 +20,7 @@
 #include <vector>
 #include <set>
 #include <cmath>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -35,6 +36,38 @@ class SpaceToBatch : public PrimitiveC {
   void SetPaddings(const std::vector<int> &paddings);
 #else
   explicit SpaceToBatch(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_SpaceToBatch();
+    MS_ASSERT(attr != nullptr);
+
+    auto blockShape = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->blockShape()->size()); i++) {
+      blockShape->push_back(attr->blockShape()->data()[i]);
+    }
+    auto paddings = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->paddings()->size()); i++) {
+      paddings->push_back(attr->paddings()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateSpaceToBatchDirect(fbb, blockShape.release(), paddings.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_SpaceToBatch, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   int InferShape(std::vector<lite::tensor::Tensor *> inputs, std::vector<lite::tensor::Tensor *> outputs) override;
 

mindspore/lite/src/ops/space_to_batch_nd.h

@@ -18,6 +18,7 @@
 #define LITE_MINDSPORE_LITE_C_OPS_SPACE_TO_BATCH_N_D_H_
 
 #include <vector>
+#include <memory>
 #include "ir/dtype/type_id.h"
 #include "src/ops/primitive_c.h"
 
@@ -33,6 +34,38 @@ class SpaceToBatchND : public PrimitiveC {
   void SetPaddings(const std::vector<int> &paddings);
 #else
   explicit SpaceToBatchND(schema::Primitive *primitive) : PrimitiveC(primitive) {}
+
+  schema::Primitive *Init(schema::Primitive *primitive) {
+    flatbuffers::FlatBufferBuilder fbb(1024);
+
+    auto attr = primitive->value_as_SpaceToBatchND();
+    MS_ASSERT(attr != nullptr);
+
+    auto blockShape = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->blockShape()->size()); i++) {
+      blockShape->push_back(attr->blockShape()->data()[i]);
+    }
+    auto paddings = std::make_unique<std::vector<int32_t>>();
+    for (int i = 0; i < static_cast<int>(attr->paddings()->size()); i++) {
+      paddings->push_back(attr->paddings()->data()[i]);
+    }
+
+    auto val_offset = schema::CreateSpaceToBatchNDDirect(fbb, blockShape.release(), paddings.release());
+    auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_SpaceToBatchND, val_offset.o);
+    fbb.Finish(prim_offset);
+
+    auto buf = fbb.GetBufferPointer();
+    MS_ASSERT(buf != nullptr);
+    auto buf_bak = new char[fbb.GetSize()];
+    memcpy(buf_bak, buf, fbb.GetSize());
+
+    auto root = flatbuffers::GetRoot<schema::Primitive>(buf_bak);
+    auto prim = const_cast<schema::Primitive *>(root);
+
+    delete[] buf_bak;
+    fbb.Clear();
+    return prim;
+  }
 #endif
   std::vector<int> GetBlockShape() const;
   std::vector<int> GetPaddings() const;