diff --git a/mindspore/lite/src/ops/abs.h b/mindspore/lite/src/ops/abs.h index 4670cfa8ed..4e9fd3c12c 100644 --- a/mindspore/lite/src/ops/abs.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/activation.h b/mindspore/lite/src/ops/activation.h index a880f660da..30fdf511d5 100644 --- a/mindspore/lite/src/ops/activation.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetType() const; float GetAlpha() const; diff --git a/mindspore/lite/src/ops/activation_grad.h b/mindspore/lite/src/ops/activation_grad.h index ccf14bf593..9c4d0dc7f9 100644 --- a/mindspore/lite/src/ops/activation_grad.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetType() const; }; diff --git a/mindspore/lite/src/ops/add.h b/mindspore/lite/src/ops/add.h index 81139f60ee..7653e2fb11 100644 --- a/mindspore/lite/src/ops/add.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetActivationType() const; }; diff --git a/mindspore/lite/src/ops/addn.h b/mindspore/lite/src/ops/addn.h index b5cd75c811..a0861b7a27 100644 --- a/mindspore/lite/src/ops/addn.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetN() const; diff --git a/mindspore/lite/src/ops/argmax.h b/mindspore/lite/src/ops/argmax.h index c744b963bf..d114195d11 100644 --- a/mindspore/lite/src/ops/argmax.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetAxis() const; diff --git a/mindspore/lite/src/ops/argmin.h b/mindspore/lite/src/ops/argmin.h index e9f09294a4..ae1b644e11 100644 --- a/mindspore/lite/src/ops/argmin.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetAxis() const; diff --git a/mindspore/lite/src/ops/batch_norm.h b/mindspore/lite/src/ops/batch_norm.h index ef826dcc9a..f030e2c32a 100644 --- a/mindspore/lite/src/ops/batch_norm.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetEpsilon() const; }; diff --git a/mindspore/lite/src/ops/batch_to_space.h b/mindspore/lite/src/ops/batch_to_space.h index 6367601c6c..6d0c333cfe 100644 --- a/mindspore/lite/src/ops/batch_to_space.h +++ b/mindspore/lite/src/ops/batch_to_space.h @@ -20,6 +20,7 @@ #include #include #include +#include #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 &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>(); + for (int i = 0; i < static_cast(attr->blockShape()->size()); i++) { + blockShape->push_back(attr->blockShape()->data()[i]); + } + auto crops = std::make_unique>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetBlockShape() const; diff --git a/mindspore/lite/src/ops/bias_add.h b/mindspore/lite/src/ops/bias_add.h index 12a3773040..e8a1354b45 100644 --- a/mindspore/lite/src/ops/bias_add.h +++ b/mindspore/lite/src/ops/bias_add.h @@ -20,6 +20,7 @@ #include #include #include +#include #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 &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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetAxis() const; }; diff --git a/mindspore/lite/src/ops/bias_grad.h b/mindspore/lite/src/ops/bias_grad.h index 09d6f5ffc8..7aaa70db64 100644 --- a/mindspore/lite/src/ops/bias_grad.h +++ b/mindspore/lite/src/ops/bias_grad.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetAxis() const; }; diff --git a/mindspore/lite/src/ops/bn_grad_input.h b/mindspore/lite/src/ops/bn_grad_input.h index fcbdefc7a7..f79fb2b631 100644 --- a/mindspore/lite/src/ops/bn_grad_input.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetEps() const; int GetChannels() const; diff --git a/mindspore/lite/src/ops/broadcast_to.h b/mindspore/lite/src/ops/broadcast_to.h index fa189e6acd..7aa64c96b4 100644 --- a/mindspore/lite/src/ops/broadcast_to.h +++ b/mindspore/lite/src/ops/broadcast_to.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetDstShape() const; diff --git a/mindspore/lite/src/ops/caffe_p_relu.h b/mindspore/lite/src/ops/caffe_p_relu.h index eeb0020e2d..fa7ba23ddc 100644 --- a/mindspore/lite/src/ops/caffe_p_relu.h +++ b/mindspore/lite/src/ops/caffe_p_relu.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif bool GetChannelShared() const; }; diff --git a/mindspore/lite/src/ops/cast.h b/mindspore/lite/src/ops/cast.h index 169c8f29fb..9c9738b7b3 100644 --- a/mindspore/lite/src/ops/cast.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetSrcT() const; diff --git a/mindspore/lite/src/ops/ceil.h b/mindspore/lite/src/ops/ceil.h index 3517fb773f..f1c241339a 100644 --- a/mindspore/lite/src/ops/ceil.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/clip.h b/mindspore/lite/src/ops/clip.h index cd89fbbef5..453863baae 100644 --- a/mindspore/lite/src/ops/clip.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetMax() const; float GetMin() const; diff --git a/mindspore/lite/src/ops/concat.h b/mindspore/lite/src/ops/concat.h index 438ffe2c37..11540624be 100644 --- a/mindspore/lite/src/ops/concat.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetAxis() const; diff --git a/mindspore/lite/src/ops/constant_of_shape.h b/mindspore/lite/src/ops/constant_of_shape.h index bce1440d1b..c03fe077cd 100644 --- a/mindspore/lite/src/ops/constant_of_shape.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; float GetValue() const; diff --git a/mindspore/lite/src/ops/conv2d.h b/mindspore/lite/src/ops/conv2d.h index a0454d02e1..992f6af107 100644 --- a/mindspore/lite/src/ops/conv2d.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif public: diff --git a/mindspore/lite/src/ops/conv2d_grad_filter.h b/mindspore/lite/src/ops/conv2d_grad_filter.h index 715b1827ab..9de5064a6e 100644 --- a/mindspore/lite/src/ops/conv2d_grad_filter.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetFormat() const; int GetGroup() const; diff --git a/mindspore/lite/src/ops/conv2d_grad_input.h b/mindspore/lite/src/ops/conv2d_grad_input.h index e7996010fb..bf37f42dbe 100644 --- a/mindspore/lite/src/ops/conv2d_grad_input.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetFormat() const; int GetGroup() const; diff --git a/mindspore/lite/src/ops/cos.h b/mindspore/lite/src/ops/cos.h index 4675c92eb5..3f3890872d 100644 --- a/mindspore/lite/src/ops/cos.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/crop.h b/mindspore/lite/src/ops/crop.h index 95ea756745..503bc67a19 100644 --- a/mindspore/lite/src/ops/crop.h +++ b/mindspore/lite/src/ops/crop.h @@ -20,6 +20,7 @@ #include #include #include +#include #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 &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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int64_t GetAxis() const; diff --git a/mindspore/lite/src/ops/deconv2d.h b/mindspore/lite/src/ops/deconv2d.h index 89b7e9fccc..1d2ebd8b4f 100644 --- a/mindspore/lite/src/ops/deconv2d.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetFormat() const; diff --git a/mindspore/lite/src/ops/dedepthwise_conv2d.h b/mindspore/lite/src/ops/dedepthwise_conv2d.h index 98318fabbd..c01427c42a 100644 --- a/mindspore/lite/src/ops/dedepthwise_conv2d.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetFormat() const; diff --git a/mindspore/lite/src/ops/depth_to_space.h b/mindspore/lite/src/ops/depth_to_space.h index 580c019391..37a0ea4d5a 100644 --- a/mindspore/lite/src/ops/depth_to_space.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetBlockSize() const; diff --git a/mindspore/lite/src/ops/depthwise_conv2d.h b/mindspore/lite/src/ops/depthwise_conv2d.h index 256ac14511..1e5c52ed85 100644 --- a/mindspore/lite/src/ops/depthwise_conv2d.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif public: diff --git a/mindspore/lite/src/ops/detection_post_process.h b/mindspore/lite/src/ops/detection_post_process.h index 2dcd7be45c..ae8bd111ca 100644 --- a/mindspore/lite/src/ops/detection_post_process.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetFormat() const; int GetInputSize() const; diff --git a/mindspore/lite/src/ops/div.h b/mindspore/lite/src/ops/div.h index 21fd8c9c97..026f41b309 100644 --- a/mindspore/lite/src/ops/div.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetActivationType() const; }; diff --git a/mindspore/lite/src/ops/dropout.h b/mindspore/lite/src/ops/dropout.h index 90197a2ae8..f8eccec19d 100644 --- a/mindspore/lite/src/ops/dropout.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetRatio() const; }; diff --git a/mindspore/lite/src/ops/eltwise.h b/mindspore/lite/src/ops/eltwise.h index cf2409cafd..7227f804f9 100644 --- a/mindspore/lite/src/ops/eltwise.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetMode() const; }; diff --git a/mindspore/lite/src/ops/elu.h b/mindspore/lite/src/ops/elu.h index 5f70dded6d..5490a2e1dc 100644 --- a/mindspore/lite/src/ops/elu.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetAlpha() const; }; diff --git a/mindspore/lite/src/ops/embedding_lookup.h b/mindspore/lite/src/ops/embedding_lookup.h index b6e2aac6ab..091140e29e 100644 --- a/mindspore/lite/src/ops/embedding_lookup.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; float GetMaxNorm() const; diff --git a/mindspore/lite/src/ops/embedding_lookup_sparse.h b/mindspore/lite/src/ops/embedding_lookup_sparse.h index 20f997d23e..d58462a5c1 100644 --- a/mindspore/lite/src/ops/embedding_lookup_sparse.h +++ b/mindspore/lite/src/ops/embedding_lookup_sparse.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(attr->spIds()->size()); i++) { + spIds->push_back(attr->spIds()->data()[i]); + } + auto spWeights = std::make_unique>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetSpIds() const; std::vector GetSpWeights() const; diff --git a/mindspore/lite/src/ops/equal.h b/mindspore/lite/src/ops/equal.h index 942aaf814c..d3e297d892 100644 --- a/mindspore/lite/src/ops/equal.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/exp.h b/mindspore/lite/src/ops/exp.h index d267eda3ce..9d47375086 100644 --- a/mindspore/lite/src/ops/exp.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/expand_dims.h b/mindspore/lite/src/ops/expand_dims.h index 6ef1f250ec..f2bd17360b 100644 --- a/mindspore/lite/src/ops/expand_dims.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetDim() const; diff --git a/mindspore/lite/src/ops/fake_quant_with_min_max_vars.h b/mindspore/lite/src/ops/fake_quant_with_min_max_vars.h index e0eccdf195..16017db716 100644 --- a/mindspore/lite/src/ops/fake_quant_with_min_max_vars.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif bool GetNarrowRange() const; int GetNumBits() const; diff --git a/mindspore/lite/src/ops/fill.h b/mindspore/lite/src/ops/fill.h index f0af3adf03..5b1d52a15c 100644 --- a/mindspore/lite/src/ops/fill.h +++ b/mindspore/lite/src/ops/fill.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetDims() const; diff --git a/mindspore/lite/src/ops/flatten.h b/mindspore/lite/src/ops/flatten.h index 701aed0a44..b10bfca5d4 100644 --- a/mindspore/lite/src/ops/flatten.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; diff --git a/mindspore/lite/src/ops/floor.h b/mindspore/lite/src/ops/floor.h index d76f603cd8..8baf469a6f 100644 --- a/mindspore/lite/src/ops/floor.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/floor_div.h b/mindspore/lite/src/ops/floor_div.h index 5d51c1f399..4fec27263a 100644 --- a/mindspore/lite/src/ops/floor_div.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/floor_mod.h b/mindspore/lite/src/ops/floor_mod.h index 33e68491ce..32c9f772db 100644 --- a/mindspore/lite/src/ops/floor_mod.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/full_connection.h b/mindspore/lite/src/ops/full_connection.h index 7f48d66741..c60ff080b7 100644 --- a/mindspore/lite/src/ops/full_connection.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; bool GetHasBias() const; diff --git a/mindspore/lite/src/ops/fused_batchnorm.h b/mindspore/lite/src/ops/fused_batchnorm.h index ea8d7ad974..a812ec343b 100644 --- a/mindspore/lite/src/ops/fused_batchnorm.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetEpsilon() const; float GetMomentum() const; diff --git a/mindspore/lite/src/ops/gather.h b/mindspore/lite/src/ops/gather.h index db0a61c5d4..81401c6f7c 100644 --- a/mindspore/lite/src/ops/gather.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetAxis() const; diff --git a/mindspore/lite/src/ops/gather_nd.h b/mindspore/lite/src/ops/gather_nd.h index 39536d1053..6e67f8c826 100644 --- a/mindspore/lite/src/ops/gather_nd.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetBatchDims() const; diff --git a/mindspore/lite/src/ops/greater.h b/mindspore/lite/src/ops/greater.h index 15326ccc0b..96c044b670 100644 --- a/mindspore/lite/src/ops/greater.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/greater_equal.h b/mindspore/lite/src/ops/greater_equal.h index 3e65322af7..8363ae3990 100644 --- a/mindspore/lite/src/ops/greater_equal.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/l2_norm.h b/mindspore/lite/src/ops/l2_norm.h index afe7e10210..17da92ba65 100644 --- a/mindspore/lite/src/ops/l2_norm.h +++ b/mindspore/lite/src/ops/l2_norm.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetAxis() const; float GetEpsilon() const; diff --git a/mindspore/lite/src/ops/leaky_relu.h b/mindspore/lite/src/ops/leaky_relu.h index 700dc65de5..6723f66e6c 100644 --- a/mindspore/lite/src/ops/leaky_relu.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetNegativeSlope() const; }; diff --git a/mindspore/lite/src/ops/less.h b/mindspore/lite/src/ops/less.h index 35c2e9fa38..5e44f5194a 100644 --- a/mindspore/lite/src/ops/less.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/less_equal.h b/mindspore/lite/src/ops/less_equal.h index b9ff464895..ee91141c95 100644 --- a/mindspore/lite/src/ops/less_equal.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/local_response_normalization.h b/mindspore/lite/src/ops/local_response_normalization.h index 8d4e6e94f5..9200d71aa7 100644 --- a/mindspore/lite/src/ops/local_response_normalization.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetDepthRadius() const; float GetBias() const; diff --git a/mindspore/lite/src/ops/log.h b/mindspore/lite/src/ops/log.h index 30b8c3171a..9a3b2f1599 100644 --- a/mindspore/lite/src/ops/log.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/logical_and.h b/mindspore/lite/src/ops/logical_and.h index 2fcea06cc9..10e1ef4817 100644 --- a/mindspore/lite/src/ops/logical_and.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/logical_not.h b/mindspore/lite/src/ops/logical_not.h index 5d0da6d625..4196ba99c8 100644 --- a/mindspore/lite/src/ops/logical_not.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/logical_or.h b/mindspore/lite/src/ops/logical_or.h index ecf54dd52f..a9e0045e30 100644 --- a/mindspore/lite/src/ops/logical_or.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/lrn.h b/mindspore/lite/src/ops/lrn.h index 34556a50cc..047971045d 100644 --- a/mindspore/lite/src/ops/lrn.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetAlpha() const; float GetBeta() const; diff --git a/mindspore/lite/src/ops/lstm.h b/mindspore/lite/src/ops/lstm.h index 7c5e70f5b3..a5e99c89b4 100644 --- a/mindspore/lite/src/ops/lstm.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; bool GetBidirection() const; diff --git a/mindspore/lite/src/ops/make_tuple.h b/mindspore/lite/src/ops/make_tuple.h index 6eaa47829d..71fd062ad7 100644 --- a/mindspore/lite/src/ops/make_tuple.h +++ b/mindspore/lite/src/ops/make_tuple.h @@ -30,6 +30,26 @@ class MakeTuple : public PrimitiveC { int UnPackAttr(const Primitive &prim, const std::vector &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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/matmul.h b/mindspore/lite/src/ops/matmul.h index 94f3332dc6..e2a863e15e 100644 --- a/mindspore/lite/src/ops/matmul.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif public: diff --git a/mindspore/lite/src/ops/matrix_diag.h b/mindspore/lite/src/ops/matrix_diag.h index 164abd1020..efb56a4e3a 100644 --- a/mindspore/lite/src/ops/matrix_diag.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetK() const; int GetNumRows() const; diff --git a/mindspore/lite/src/ops/maximum.h b/mindspore/lite/src/ops/maximum.h index 6df4141d5c..e0c1ab17cb 100644 --- a/mindspore/lite/src/ops/maximum.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/mean.h b/mindspore/lite/src/ops/mean.h index cae4487b65..9c9aec4ede 100644 --- a/mindspore/lite/src/ops/mean.h +++ b/mindspore/lite/src/ops/mean.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetAxis() const; diff --git a/mindspore/lite/src/ops/minimum.h b/mindspore/lite/src/ops/minimum.h index f608f65a91..d0901701b5 100644 --- a/mindspore/lite/src/ops/minimum.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/mul.h b/mindspore/lite/src/ops/mul.h index d1d428e397..aaad8775ae 100644 --- a/mindspore/lite/src/ops/mul.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetActivationType() const; diff --git a/mindspore/lite/src/ops/nchw2nhwc.h b/mindspore/lite/src/ops/nchw2nhwc.h index 31758e0efd..9eb342c6a0 100644 --- a/mindspore/lite/src/ops/nchw2nhwc.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; }; diff --git a/mindspore/lite/src/ops/nhwc2nchw.h b/mindspore/lite/src/ops/nhwc2nchw.h index d03411dae1..50bce7c668 100644 --- a/mindspore/lite/src/ops/nhwc2nchw.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; }; diff --git a/mindspore/lite/src/ops/not_equal.h b/mindspore/lite/src/ops/not_equal.h index 8c8d02efdd..67b6afb047 100644 --- a/mindspore/lite/src/ops/not_equal.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/one_hot.h b/mindspore/lite/src/ops/one_hot.h index 125b788cc1..ab32af0d57 100644 --- a/mindspore/lite/src/ops/one_hot.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetAxis() const; diff --git a/mindspore/lite/src/ops/pad.h b/mindspore/lite/src/ops/pad.h index 08f264a6f2..d7f5797d29 100644 --- a/mindspore/lite/src/ops/pad.h +++ b/mindspore/lite/src/ops/pad.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetPaddings() const; diff --git a/mindspore/lite/src/ops/permute.h b/mindspore/lite/src/ops/permute.h index ff9c6506f9..b7433bd08c 100644 --- a/mindspore/lite/src/ops/permute.h +++ b/mindspore/lite/src/ops/permute.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetOrder() const; void SetOrder(const std::vector &order); diff --git a/mindspore/lite/src/ops/pooling.h b/mindspore/lite/src/ops/pooling.h index b6aed86409..d4f13fd553 100644 --- a/mindspore/lite/src/ops/pooling.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetFormat() const; diff --git a/mindspore/lite/src/ops/pooling_grad.h b/mindspore/lite/src/ops/pooling_grad.h index 0fbec8547e..ac0e58ff9f 100644 --- a/mindspore/lite/src/ops/pooling_grad.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetFormat() const; int GetPoolingMode() const; diff --git a/mindspore/lite/src/ops/power.h b/mindspore/lite/src/ops/power.h index 3f98b191c0..d607c8b889 100644 --- a/mindspore/lite/src/ops/power.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; float GetPower() const; diff --git a/mindspore/lite/src/ops/power_grad.h b/mindspore/lite/src/ops/power_grad.h index 91218e5f55..8fe000586e 100644 --- a/mindspore/lite/src/ops/power_grad.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif float GetPower() const; float GetScale() const; diff --git a/mindspore/lite/src/ops/prelu.h b/mindspore/lite/src/ops/prelu.h index 07f5a39cac..4a5fa42718 100644 --- a/mindspore/lite/src/ops/prelu.h +++ b/mindspore/lite/src/ops/prelu.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetSlope() const; }; diff --git a/mindspore/lite/src/ops/prior_box.h b/mindspore/lite/src/ops/prior_box.h index a91557e486..8012b406d5 100644 --- a/mindspore/lite/src/ops/prior_box.h +++ b/mindspore/lite/src/ops/prior_box.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(attr->min_sizes()->size()); i++) { + min_sizes->push_back(attr->min_sizes()->data()[i]); + } + auto max_sizes = std::make_unique>(); + for (int i = 0; i < static_cast(attr->max_sizes()->size()); i++) { + max_sizes->push_back(attr->max_sizes()->data()[i]); + } + auto aspect_ratios = std::make_unique>(); + for (int i = 0; i < static_cast(attr->aspect_ratios()->size()); i++) { + aspect_ratios->push_back(attr->aspect_ratios()->data()[i]); + } + auto variances = std::make_unique>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetMinSizes() const; diff --git a/mindspore/lite/src/ops/quant_dtype_cast.h b/mindspore/lite/src/ops/quant_dtype_cast.h index b666791cee..7357461cf1 100644 --- a/mindspore/lite/src/ops/quant_dtype_cast.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetSrcT() const; diff --git a/mindspore/lite/src/ops/range.h b/mindspore/lite/src/ops/range.h index e543203be7..6b1ac596e4 100644 --- a/mindspore/lite/src/ops/range.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetDType() const; diff --git a/mindspore/lite/src/ops/rank.h b/mindspore/lite/src/ops/rank.h index 5dfb59c468..2e5f7c7895 100644 --- a/mindspore/lite/src/ops/rank.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; }; diff --git a/mindspore/lite/src/ops/reduce.h b/mindspore/lite/src/ops/reduce.h index 4ae748bad2..3bea756cc5 100644 --- a/mindspore/lite/src/ops/reduce.h +++ b/mindspore/lite/src/ops/reduce.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetAxes() const; diff --git a/mindspore/lite/src/ops/reshape.h b/mindspore/lite/src/ops/reshape.h index d277b4156e..76eccc9421 100644 --- a/mindspore/lite/src/ops/reshape.h +++ b/mindspore/lite/src/ops/reshape.h @@ -20,6 +20,7 @@ #include #include #include +#include #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 &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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetFormat() const; diff --git a/mindspore/lite/src/ops/resize.h b/mindspore/lite/src/ops/resize.h index c4dd9c4139..98a52fbfcd 100644 --- a/mindspore/lite/src/ops/resize.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetFormat() const; diff --git a/mindspore/lite/src/ops/reverse.h b/mindspore/lite/src/ops/reverse.h index bf3fe96f27..7b895b394e 100644 --- a/mindspore/lite/src/ops/reverse.h +++ b/mindspore/lite/src/ops/reverse.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetAxis() const; }; diff --git a/mindspore/lite/src/ops/reverse_sequence.h b/mindspore/lite/src/ops/reverse_sequence.h index f9e6c40105..b197e546a2 100644 --- a/mindspore/lite/src/ops/reverse_sequence.h +++ b/mindspore/lite/src/ops/reverse_sequence.h @@ -20,6 +20,7 @@ #include #include #include +#include #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 &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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetSeqAxis() const; diff --git a/mindspore/lite/src/ops/roi_pooling.h b/mindspore/lite/src/ops/roi_pooling.h index 19183b3290..876850b504 100644 --- a/mindspore/lite/src/ops/roi_pooling.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetPooledH() const; diff --git a/mindspore/lite/src/ops/round.h b/mindspore/lite/src/ops/round.h index ff0a000b2c..b253c0728e 100644 --- a/mindspore/lite/src/ops/round.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/rsqrt.h b/mindspore/lite/src/ops/rsqrt.h index 40014a9a26..77ae116dcc 100644 --- a/mindspore/lite/src/ops/rsqrt.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/scale.h b/mindspore/lite/src/ops/scale.h index 0c17db8b14..1a22998583 100644 --- a/mindspore/lite/src/ops/scale.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetAxis() const; }; diff --git a/mindspore/lite/src/ops/scatter_nd.h b/mindspore/lite/src/ops/scatter_nd.h index d87adc1485..a5afb3471e 100644 --- a/mindspore/lite/src/ops/scatter_nd.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; }; diff --git a/mindspore/lite/src/ops/shape.h b/mindspore/lite/src/ops/shape.h index cec796e475..eb6e8218ed 100644 --- a/mindspore/lite/src/ops/shape.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; }; diff --git a/mindspore/lite/src/ops/sin.h b/mindspore/lite/src/ops/sin.h index 587ba8c094..db1076a786 100644 --- a/mindspore/lite/src/ops/sin.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/slice.h b/mindspore/lite/src/ops/slice.h index 1bf67ae798..8c7995ee80 100644 --- a/mindspore/lite/src/ops/slice.h +++ b/mindspore/lite/src/ops/slice.h @@ -20,6 +20,7 @@ #include #include #include +#include #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 &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>(); + for (int i = 0; i < static_cast(attr->begin()->size()); i++) { + begin->push_back(attr->begin()->data()[i]); + } + auto size = std::make_unique>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector 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 GetPostProcessBegin() const; std::vector GetPostProcessSize() const; + protected: std::vector begin = {0}; std::vector size = {-1}; diff --git a/mindspore/lite/src/ops/softmax.h b/mindspore/lite/src/ops/softmax.h index b93d910767..bd39b4de0c 100644 --- a/mindspore/lite/src/ops/softmax.h +++ b/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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetAxis() const; diff --git a/mindspore/lite/src/ops/softmax_cross_entropy.h b/mindspore/lite/src/ops/softmax_cross_entropy.h index 4734d01de3..a054235c61 100644 --- a/mindspore/lite/src/ops/softmax_cross_entropy.h +++ b/mindspore/lite/src/ops/softmax_cross_entropy.h @@ -20,6 +20,7 @@ #include #include #include +#include #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>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetAxis() const; }; diff --git a/mindspore/lite/src/ops/space_to_batch.h b/mindspore/lite/src/ops/space_to_batch.h index 5257a6e4d6..f1e0b3811b 100644 --- a/mindspore/lite/src/ops/space_to_batch.h +++ b/mindspore/lite/src/ops/space_to_batch.h @@ -20,6 +20,7 @@ #include #include #include +#include #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 &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>(); + for (int i = 0; i < static_cast(attr->blockShape()->size()); i++) { + blockShape->push_back(attr->blockShape()->data()[i]); + } + auto paddings = std::make_unique>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs, std::vector outputs) override; diff --git a/mindspore/lite/src/ops/space_to_batch_nd.h b/mindspore/lite/src/ops/space_to_batch_nd.h index 4b53a77153..24ae7c4a2a 100644 --- a/mindspore/lite/src/ops/space_to_batch_nd.h +++ b/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 +#include #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 &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>(); + for (int i = 0; i < static_cast(attr->blockShape()->size()); i++) { + blockShape->push_back(attr->blockShape()->data()[i]); + } + auto paddings = std::make_unique>(); + for (int i = 0; i < static_cast(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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetBlockShape() const; std::vector GetPaddings() const; diff --git a/mindspore/lite/src/ops/space_to_depth.h b/mindspore/lite/src/ops/space_to_depth.h index 1324844478..fde2639a9b 100644 --- a/mindspore/lite/src/ops/space_to_depth.h +++ b/mindspore/lite/src/ops/space_to_depth.h @@ -35,6 +35,29 @@ class SpaceToDepth : public PrimitiveC { void SetFormat(int format); #else explicit SpaceToDepth(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_SpaceToDepth(); + MS_ASSERT(attr != nullptr); + + auto val_offset = schema::CreateSpaceToDepth(fbb, attr->blockSize(), attr->format()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_SpaceToDepth, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetBlockSize() const; diff --git a/mindspore/lite/src/ops/sparse_to_dense.h b/mindspore/lite/src/ops/sparse_to_dense.h index c10791c8d3..14acfce282 100644 --- a/mindspore/lite/src/ops/sparse_to_dense.h +++ b/mindspore/lite/src/ops/sparse_to_dense.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -37,6 +38,43 @@ class SparseToDense : public PrimitiveC { void SetValidateIndices(bool validate_indices); #else explicit SparseToDense(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_SparseToDense(); + MS_ASSERT(attr != nullptr); + + auto outputShape = std::make_unique>(); + for (int i = 0; i < static_cast(attr->outputShape()->size()); i++) { + outputShape->push_back(attr->outputShape()->data()[i]); + } + auto sparseValue = std::make_unique>(); + for (int i = 0; i < static_cast(attr->sparseValue()->size()); i++) { + sparseValue->push_back(attr->sparseValue()->data()[i]); + } + auto defaultValue = std::make_unique>(); + for (int i = 0; i < static_cast(attr->defaultValue()->size()); i++) { + defaultValue->push_back(attr->defaultValue()->data()[i]); + } + + auto val_offset = schema::CreateSparseToDenseDirect(fbb, outputShape.release(), + sparseValue.release(), defaultValue.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_SparseToDense, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::vector GetOutputShape() const; std::vector GetSparseValue() const; diff --git a/mindspore/lite/src/ops/split.h b/mindspore/lite/src/ops/split.h index cb12b02217..4f94948b07 100644 --- a/mindspore/lite/src/ops/split.h +++ b/mindspore/lite/src/ops/split.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -36,6 +37,34 @@ class Split : public PrimitiveC { void SetSplitDim(int split_dim); #else explicit Split(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Split(); + MS_ASSERT(attr != nullptr); + + auto sizeSplits = std::make_unique>(); + for (int i = 0; i < static_cast(attr->sizeSplits()->size()); i++) { + sizeSplits->push_back(attr->sizeSplits()->data()[i]); + } + + auto val_offset = schema::CreateSplitDirect(fbb, attr->numberSplit(), sizeSplits.release(), attr->splitDim()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Split, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetNumberSplit() const; diff --git a/mindspore/lite/src/ops/sqrt.h b/mindspore/lite/src/ops/sqrt.h index 30386e7a78..0121de2a49 100644 --- a/mindspore/lite/src/ops/sqrt.h +++ b/mindspore/lite/src/ops/sqrt.h @@ -33,6 +33,26 @@ class Sqrt : public ArithmeticSelf { explicit Sqrt(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {} #else explicit Sqrt(schema::Primitive *primitive) : ArithmeticSelf(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto val_offset = schema::CreateSqrt(fbb); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Sqrt, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/square.h b/mindspore/lite/src/ops/square.h index 7869eaeaa9..8762aff94e 100644 --- a/mindspore/lite/src/ops/square.h +++ b/mindspore/lite/src/ops/square.h @@ -32,6 +32,26 @@ class Square : public ArithmeticSelf { explicit Square(schema::PrimitiveT *primitive) : ArithmeticSelf(primitive) {} #else explicit Square(schema::Primitive *primitive) : ArithmeticSelf(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto val_offset = schema::CreateSquare(fbb); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Square, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/squared_difference.h b/mindspore/lite/src/ops/squared_difference.h index a893c9a775..4893289941 100644 --- a/mindspore/lite/src/ops/squared_difference.h +++ b/mindspore/lite/src/ops/squared_difference.h @@ -33,6 +33,26 @@ class SquaredDifference : public Arithmetic { explicit SquaredDifference(schema::PrimitiveT *primitive) : Arithmetic(primitive) {} #else explicit SquaredDifference(schema::Primitive *primitive) : Arithmetic(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto val_offset = schema::CreateSquaredDifference(fbb); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_SquaredDifference, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/squeeze.h b/mindspore/lite/src/ops/squeeze.h index b6e2c4e784..7da4a13044 100644 --- a/mindspore/lite/src/ops/squeeze.h +++ b/mindspore/lite/src/ops/squeeze.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -35,6 +36,34 @@ class Squeeze : public PrimitiveC { #else explicit Squeeze(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Squeeze(); + MS_ASSERT(attr != nullptr); + + auto axis = std::make_unique>(); + for (int i = 0; i < static_cast(attr->axis()->size()); i++) { + axis->push_back(attr->axis()->data()[i]); + } + + auto val_offset = schema::CreateSqueezeDirect(fbb, axis.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Squeeze, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetAxis() const; diff --git a/mindspore/lite/src/ops/stack.h b/mindspore/lite/src/ops/stack.h index cdbb47ca54..ffd39877ee 100644 --- a/mindspore/lite/src/ops/stack.h +++ b/mindspore/lite/src/ops/stack.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -36,6 +37,34 @@ class Stack : public PrimitiveC { void SetIsScale(const std::vector &is_scale); #else explicit Stack(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Stack(); + MS_ASSERT(attr != nullptr); + + auto isScale = std::make_unique>(); + for (int i = 0; i < static_cast(attr->isScale()->size()); i++) { + isScale->push_back(attr->isScale()->data()[i]); + } + + auto val_offset = schema::CreateStackDirect(fbb, attr->axis(), attr->n(), isScale.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Stack, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetAxis() const; diff --git a/mindspore/lite/src/ops/strided_slice.h b/mindspore/lite/src/ops/strided_slice.h index 47468c1ef5..49f634fc81 100644 --- a/mindspore/lite/src/ops/strided_slice.h +++ b/mindspore/lite/src/ops/strided_slice.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -42,6 +43,48 @@ class StridedSlice : public PrimitiveC { void SetIsScale(const std::vector &is_scale); #else explicit StridedSlice(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_StridedSlice(); + MS_ASSERT(attr != nullptr); + + auto begin = std::make_unique>(); + for (int i = 0; i < static_cast(attr->begin()->size()); i++) { + begin->push_back(attr->begin()->data()[i]); + } + auto end = std::make_unique>(); + for (int i = 0; i < static_cast(attr->end()->size()); i++) { + end->push_back(attr->end()->data()[i]); + } + auto stride = std::make_unique>(); + for (int i = 0; i < static_cast(attr->stride()->size()); i++) { + stride->push_back(attr->stride()->data()[i]); + } + auto isScale = std::make_unique>(); + for (int i = 0; i < static_cast(attr->isScale()->size()); i++) { + isScale->push_back(attr->isScale()->data()[i]); + } + + auto val_offset = schema::CreateStridedSliceDirect(fbb, attr->beginMask(), attr->endMask(), attr->ellipsisMask(), + attr->newAxisMask(), attr->shrinkAxisMask(), begin.release(), + end.release(), stride.release(), isScale.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_StridedSlice, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetBeginMask() const; diff --git a/mindspore/lite/src/ops/sub.h b/mindspore/lite/src/ops/sub.h index ec8a95ac0e..8faf0331c9 100644 --- a/mindspore/lite/src/ops/sub.h +++ b/mindspore/lite/src/ops/sub.h @@ -35,6 +35,29 @@ class Sub : public Arithmetic { #else explicit Sub(schema::Primitive *primitive) : Arithmetic(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Sub(); + MS_ASSERT(attr != nullptr); + + auto val_offset = schema::CreateSub(fbb, attr->activationType()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Sub, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int GetActivationType() const; }; diff --git a/mindspore/lite/src/ops/tile.h b/mindspore/lite/src/ops/tile.h index 4b55278a4f..960586e155 100644 --- a/mindspore/lite/src/ops/tile.h +++ b/mindspore/lite/src/ops/tile.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -36,6 +37,38 @@ class Tile : public PrimitiveC { #else explicit Tile(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Tile(); + MS_ASSERT(attr != nullptr); + + auto multiples = std::make_unique>(); + for (int i = 0; i < static_cast(attr->multiples()->size()); i++) { + multiples->push_back(attr->multiples()->data()[i]); + } + auto dims = std::make_unique>(); + for (int i = 0; i < static_cast(attr->dims()->size()); i++) { + dims->push_back(attr->dims()->data()[i]); + } + + auto val_offset = schema::CreateTileDirect(fbb, multiples.release(), dims.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Tile, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetMultiples() const; diff --git a/mindspore/lite/src/ops/topk.h b/mindspore/lite/src/ops/topk.h index a6868e94da..a7510d59dd 100644 --- a/mindspore/lite/src/ops/topk.h +++ b/mindspore/lite/src/ops/topk.h @@ -35,6 +35,29 @@ class TopK : public PrimitiveC { void SetSorted(bool sorted); #else explicit TopK(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_TopK(); + MS_ASSERT(attr != nullptr); + + auto val_offset = schema::CreateTopK(fbb, attr->k(), attr->sorted()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_TopK, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetK() const; diff --git a/mindspore/lite/src/ops/transpose.h b/mindspore/lite/src/ops/transpose.h index 8d2d7bd55f..013fcfb5df 100644 --- a/mindspore/lite/src/ops/transpose.h +++ b/mindspore/lite/src/ops/transpose.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -36,6 +37,34 @@ class Transpose : public PrimitiveC { void SetConjugate(bool conjugate); #else explicit Transpose(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Transpose(); + MS_ASSERT(attr != nullptr); + + auto perm = std::make_unique>(); + for (int i = 0; i < static_cast(attr->perm()->size()); i++) { + perm->push_back(attr->perm()->data()[i]); + } + + auto val_offset = schema::CreateTransposeDirect(fbb, perm.release(), attr->conjugate()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Transpose, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetPerm() const; diff --git a/mindspore/lite/src/ops/tuple_get_item.h b/mindspore/lite/src/ops/tuple_get_item.h index 5cb38041cf..925c5f6b3e 100644 --- a/mindspore/lite/src/ops/tuple_get_item.h +++ b/mindspore/lite/src/ops/tuple_get_item.h @@ -31,6 +31,26 @@ class TupleGetItem : public PrimitiveC { int UnPackAttr(const Primitive &prim, const std::vector &inputs); #else explicit TupleGetItem(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto val_offset = schema::CreateTupleGetItem(fbb); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_TupleGetItem, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif }; } // namespace lite diff --git a/mindspore/lite/src/ops/unique.h b/mindspore/lite/src/ops/unique.h index 12313248e7..46c75b5005 100644 --- a/mindspore/lite/src/ops/unique.h +++ b/mindspore/lite/src/ops/unique.h @@ -35,6 +35,29 @@ class Unique : public PrimitiveC { #else explicit Unique(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Unique(); + MS_ASSERT(attr != nullptr); + + auto val_offset = schema::CreateUnique(fbb, attr->outType()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Unique, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetOutType() const; diff --git a/mindspore/lite/src/ops/unsqueeze.h b/mindspore/lite/src/ops/unsqueeze.h index 403e075c4c..5092496e42 100644 --- a/mindspore/lite/src/ops/unsqueeze.h +++ b/mindspore/lite/src/ops/unsqueeze.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -35,6 +36,34 @@ class Unsqueeze : public PrimitiveC { #else explicit Unsqueeze(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Unsqueeze(); + MS_ASSERT(attr != nullptr); + + auto axis = std::make_unique>(); + for (int i = 0; i < static_cast(attr->axis()->size()); i++) { + axis->push_back(attr->axis()->data()[i]); + } + + auto val_offset = schema::CreateUnsqueezeDirect(fbb, axis.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Unsqueeze, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetAxis() const; diff --git a/mindspore/lite/src/ops/unstack.h b/mindspore/lite/src/ops/unstack.h index 4a6bde7458..b4590ae0e8 100644 --- a/mindspore/lite/src/ops/unstack.h +++ b/mindspore/lite/src/ops/unstack.h @@ -35,6 +35,29 @@ class Unstack : public PrimitiveC { void SetAxis(int axis); #else explicit Unstack(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Unstack(); + MS_ASSERT(attr != nullptr); + + auto val_offset = schema::CreateUnstack(fbb, attr->num(), attr->axis()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Unstack, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; int GetNum() const; diff --git a/mindspore/lite/src/ops/upsample.h b/mindspore/lite/src/ops/upsample.h index 402f83dc0c..bbf67e83fa 100644 --- a/mindspore/lite/src/ops/upsample.h +++ b/mindspore/lite/src/ops/upsample.h @@ -21,6 +21,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -36,6 +37,34 @@ class Upsample : public PrimitiveC { void SetScales(const std::vector &scales); #else explicit Upsample(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Upsample(); + MS_ASSERT(attr != nullptr); + + auto scales = std::make_unique>(); + for (int i = 0; i < static_cast(attr->scales()->size()); i++) { + scales->push_back(attr->scales()->data()[i]); + } + + auto val_offset = schema::CreateUpsampleDirect(fbb, attr->mode()->c_str(), scales.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Upsample, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif std::string GetMode() const; std::vector GetScales() const; diff --git a/mindspore/lite/src/ops/where.h b/mindspore/lite/src/ops/where.h index 2c4b547bb4..7df2a83fac 100644 --- a/mindspore/lite/src/ops/where.h +++ b/mindspore/lite/src/ops/where.h @@ -20,6 +20,7 @@ #include #include #include +#include #include "ir/dtype/type_id.h" #include "src/ops/primitive_c.h" @@ -35,6 +36,34 @@ class Where : public PrimitiveC { #else explicit Where(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto attr = primitive->value_as_Where(); + MS_ASSERT(attr != nullptr); + + auto condition = std::make_unique>(); + for (int i = 0; i < static_cast(attr->condition()->size()); i++) { + condition->push_back(attr->condition()->data()[i]); + } + + auto val_offset = schema::CreateWhereDirect(fbb, condition.release()); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_Where, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; std::vector GetCondition() const; diff --git a/mindspore/lite/src/ops/zeros_like.h b/mindspore/lite/src/ops/zeros_like.h index 2a71604f1f..3a9d038923 100644 --- a/mindspore/lite/src/ops/zeros_like.h +++ b/mindspore/lite/src/ops/zeros_like.h @@ -33,6 +33,26 @@ class ZerosLike : public PrimitiveC { explicit ZerosLike(schema::PrimitiveT *primitive) : PrimitiveC(primitive) {} #else explicit ZerosLike(schema::Primitive *primitive) : PrimitiveC(primitive) {} + + schema::Primitive *Init(schema::Primitive *primitive) { + flatbuffers::FlatBufferBuilder fbb(1024); + + auto val_offset = schema::CreateZerosLike(fbb); + auto prim_offset = schema::CreatePrimitive(fbb, schema::PrimitiveType_ZerosLike, 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(buf_bak); + auto prim = const_cast(root); + + delete[] buf_bak; + fbb.Clear(); + return prim; + } #endif int InferShape(std::vector inputs_, std::vector outputs_) override; };