p60975123
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

modify ops_def

This commit is contained in:
liuyu 2021-04-29 11:10:45 +08:00
parent ef0431e5c9
commit bb85500df1
9 changed files with 464 additions and 470 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
mindspore/lite/src/ops/ops_def.cc
View File

@ -455,16 +455,16 @@ OP_ATTR(weight_threshold, float)
OP_SCHEMA_DEF_END(CustomPredict)
OP_SCHEMA_DEF(DeConv2DGradFilter)
OP_ATTR(in_channel, long);
OP_ATTR(out_channel, long);
OP_ATTR(kernel_size, [long]);
OP_ATTR_ENUM(pad_mode, PadMode);
OP_ATTR(pad_list, [long]);
OP_ATTR(stride, [long]);
OP_ATTR(dilation, [long]);
OP_ATTR(group, long);
OP_ATTR_ENUM(format, Format);
OP_ATTR_ENUM(activation_type, ActivationType);
OP_ATTR(in_channel, long)
OP_ATTR(out_channel, long)
OP_ATTR(kernel_size, [long])
OP_ATTR_ENUM(pad_mode, PadMode)
OP_ATTR(pad_list, [long])
OP_ATTR(stride, [long])
OP_ATTR(dilation, [long])
OP_ATTR(group, long)
OP_ATTR_ENUM(format, Format)
OP_ATTR_ENUM(activation_type, ActivationType)
OP_SCHEMA_DEF_END(DeConv2DGradFilter)
OP_SCHEMA_DEF(Depend)

91
mindspore/lite/src/ops/ops_def.h
View File

@ -58,10 +58,13 @@
op_def.append(" {\n");
#elif PRIMITIVE_WRITEABLE
#define OP_SCHEMA_DEF(OP) \
namespace mindspore::lite::ops { \
mindspore::schema::PrimitiveT *MSOp2SchemaOp(const mindspore::ops::OP *op) { \
mindspore::schema::OP##T *schema_op = new (std::nothrow) mindspore::schema::OP##T();
#define OP_SCHEMA_DEF(OP) \
namespace mindspore::lite::ops { \
std::unique_ptr<schema::PrimitiveT> MSOp2SchemaOp(const mindspore::ops::OP *op) { \
auto schema_op = std::make_unique<schema::OP##T>(); \
if (schema_op == nullptr) { \
return nullptr; \
}
#else
#define OP_SCHEMA_DEF(OP)
#endif
@ -71,34 +74,32 @@
#define OP_ATTR_ENUM(key, type) op_def.append(" ").append(#key).append(": ").append(#type).append(";\n");
#define OP_ATTR_VEC2D(key, type) op_def.append(" ").append(#key).append(": ").append(#type).append(";\n");
#elif PRIMITIVE_WRITEABLE
#define OP_ATTR(key, type) \
if (schema_op != nullptr) { \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = op->get_##key(); \
} \
} else { \
return nullptr; \
#define OP_ATTR(key, type) \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = op->get_##key(); \
}
#define OP_ATTR_ENUM(key, type) \
if (schema_op != nullptr) { \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = static_cast<schema::type>(op->get_##key()); \
} \
#define OP_ATTR_ENUM(key, type) \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = static_cast<schema::type>(op->get_##key()); \
}
#define OP_ATTR_VEC2D(key, type) \
if (schema_op != nullptr) { \
auto vec2d = std::make_unique<schema::Vec2DT>(); \
if (op->GetAttr(#key) != nullptr) { \
auto data = op->get_##key(); \
for (size_t i = 0; i < data.size(); ++i) { \
auto vec = std::make_unique<schema::VecT>(); \
vec->data.assign(data.at(i).begin(), data.at(i).end()); \
vec2d->data.push_back(std::move(vec)); \
} \
schema_op->key = std::move(vec2d); \
} \
#define OP_ATTR_VEC2D(key, type) \
if (op->GetAttr(#key) != nullptr) { \
auto vec2d = std::make_unique<schema::Vec2DT>(); \
if (vec2d == nullptr) { \
return nullptr; \
} \
auto data = op->get_##key(); \
for (size_t i = 0; i < data.size(); ++i) { \
auto vec = std::make_unique<schema::VecT>(); \
if (vec == nullptr) { \
return nullptr; \
} \
vec->data.assign(data.at(i).begin(), data.at(i).end()); \
vec2d->data.push_back(std::move(vec)); \
} \
schema_op->key = std::move(vec2d); \
}
#else
@ -114,19 +115,13 @@
op_def.append(" ").append(#key).append(": ").append(#type).append(" = ").append(#value).append(";\n");
#elif PRIMITIVE_WRITEABLE
#define OP_ATTR_WITH_VALUE(key, type, value) \
if (schema_op != nullptr) { \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = op->get_##key(); \
} \
} else { \
return nullptr; \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = op->get_##key(); \
}
#define OP_ATTR_ENUM_WITH_VALUE(key, type, value) \
if (schema_op != nullptr) { \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = static_cast<schema::type>(op->get_##key()); \
} \
#define OP_ATTR_ENUM_WITH_VALUE(key, type, value) \
if (op->GetAttr(#key) != nullptr) { \
schema_op->key = static_cast<schema::type>(op->get_##key()); \
}
#else
#define OP_ATTR_WITH_VALUE(key, type, value)
@ -141,15 +136,15 @@
SchemaOpRegister g_schema_op_##OP(Gen##OP##Def); \
} // namespace mindspore::lite::ops
#elif PRIMITIVE_WRITEABLE
#define OP_SCHEMA_DEF_END(OP) \
schema::PrimitiveT *prim = new (std::nothrow) schema::PrimitiveT(); \
if (prim == nullptr) { \
return nullptr; \
} \
prim->value.value = schema_op; \
prim->value.type = schema::PrimitiveType_##OP; \
return prim; \
} \
#define OP_SCHEMA_DEF_END(OP) \
auto prim = std::make_unique<schema::PrimitiveT>(); \
if (prim == nullptr) { \
return nullptr; \
} \
prim->value.value = schema_op.release(); \
prim->value.type = schema::PrimitiveType_##OP; \
return prim; \
} \
} // namespace mindspore::lite::ops
#else
#define OP_SCHEMA_DEF_END(OP)

418
mindspore/lite/src/ops/ops_func_declare.h
View File

@ -17,6 +17,7 @@
#define MINDSPORE_LITE_SRC_OPS_OPS_FUNC_DECLARE_H_
#ifdef PRIMITIVE_WRITEABLE
#include <memory>
#include "schema/inner/model_generated.h"
#include "ops/abs.h"
#include "ops/adam.h"
@ -239,216 +240,215 @@
#include "ops/cumsum.h"
#include "ops/split_with_overlap.h"
#define FUNC_MSOP2SCHEMAOP_DECLARE(OP) \
namespace mindspore::lite::ops { \
mindspore::schema::PrimitiveT *MSOp2SchemaOp(const mindspore::ops::OP *op); \
}
namespace mindspore::lite::ops {
#define FUNC_MSOP2SCHEMAOP_DECLARE(OP) std::unique_ptr<schema::PrimitiveT> MSOp2SchemaOp(const mindspore::ops::OP *op);
#ifdef PRIMITIVE_WRITEABLE
FUNC_MSOP2SCHEMAOP_DECLARE(Abs)
FUNC_MSOP2SCHEMAOP_DECLARE(Activation)
FUNC_MSOP2SCHEMAOP_DECLARE(ActivationGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Adam)
FUNC_MSOP2SCHEMAOP_DECLARE(AddFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(AdderFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(AddGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(AddN)
FUNC_MSOP2SCHEMAOP_DECLARE(All)
FUNC_MSOP2SCHEMAOP_DECLARE(ApplyMomentum)
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMax)
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMaxFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMin)
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMinFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Asin)
FUNC_MSOP2SCHEMAOP_DECLARE(Assert)
FUNC_MSOP2SCHEMAOP_DECLARE(Assign)
FUNC_MSOP2SCHEMAOP_DECLARE(AssignAdd)
FUNC_MSOP2SCHEMAOP_DECLARE(Atan)
FUNC_MSOP2SCHEMAOP_DECLARE(AudioSpectrogram)
FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(BatchNorm)
FUNC_MSOP2SCHEMAOP_DECLARE(BatchNormGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpace)
FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpaceND)
FUNC_MSOP2SCHEMAOP_DECLARE(BiasAdd)
FUNC_MSOP2SCHEMAOP_DECLARE(BiasAddGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropy)
FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropyGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(BroadcastTo)
FUNC_MSOP2SCHEMAOP_DECLARE(Cast)
FUNC_MSOP2SCHEMAOP_DECLARE(Ceil)
FUNC_MSOP2SCHEMAOP_DECLARE(Clip)
FUNC_MSOP2SCHEMAOP_DECLARE(Concat)
FUNC_MSOP2SCHEMAOP_DECLARE(ControlDepend)
FUNC_MSOP2SCHEMAOP_DECLARE(ConstantOfShape)
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropFilterFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropInputFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2dTransposeFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Cos)
FUNC_MSOP2SCHEMAOP_DECLARE(Crop)
FUNC_MSOP2SCHEMAOP_DECLARE(CustomExtractFeatures)
FUNC_MSOP2SCHEMAOP_DECLARE(CustomNormalize)
FUNC_MSOP2SCHEMAOP_DECLARE(CustomPredict)
FUNC_MSOP2SCHEMAOP_DECLARE(DeConv2DGradFilter)
FUNC_MSOP2SCHEMAOP_DECLARE(Depend)
FUNC_MSOP2SCHEMAOP_DECLARE(DepthToSpace)
FUNC_MSOP2SCHEMAOP_DECLARE(DetectionPostProcess)
FUNC_MSOP2SCHEMAOP_DECLARE(DivFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(DivGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Dropout)
FUNC_MSOP2SCHEMAOP_DECLARE(DropoutGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Eltwise)
FUNC_MSOP2SCHEMAOP_DECLARE(Elu)
FUNC_MSOP2SCHEMAOP_DECLARE(EmbeddingLookupFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Equal)
FUNC_MSOP2SCHEMAOP_DECLARE(ExpFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(ExpandDims)
FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVars)
FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVarsPerChannel)
FUNC_MSOP2SCHEMAOP_DECLARE(FftImag)
FUNC_MSOP2SCHEMAOP_DECLARE(FftReal)
FUNC_MSOP2SCHEMAOP_DECLARE(Fill)
FUNC_MSOP2SCHEMAOP_DECLARE(Flatten)
FUNC_MSOP2SCHEMAOP_DECLARE(FlattenGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Floor)
FUNC_MSOP2SCHEMAOP_DECLARE(FloorDiv)
FUNC_MSOP2SCHEMAOP_DECLARE(FloorMod)
FUNC_MSOP2SCHEMAOP_DECLARE(FullConnection)
FUNC_MSOP2SCHEMAOP_DECLARE(FusedBatchNorm)
FUNC_MSOP2SCHEMAOP_DECLARE(Gather)
FUNC_MSOP2SCHEMAOP_DECLARE(GatherNd)
FUNC_MSOP2SCHEMAOP_DECLARE(Greater)
FUNC_MSOP2SCHEMAOP_DECLARE(GreaterEqual)
FUNC_MSOP2SCHEMAOP_DECLARE(GroupConv2DGradInput)
FUNC_MSOP2SCHEMAOP_DECLARE(HashtableLookup)
FUNC_MSOP2SCHEMAOP_DECLARE(InstanceNorm)
FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(LeakyRelu)
FUNC_MSOP2SCHEMAOP_DECLARE(Less)
FUNC_MSOP2SCHEMAOP_DECLARE(LessEqual)
FUNC_MSOP2SCHEMAOP_DECLARE(Log)
FUNC_MSOP2SCHEMAOP_DECLARE(LogGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalAnd)
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalNot)
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalOr)
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalXor)
FUNC_MSOP2SCHEMAOP_DECLARE(LpNormalization)
FUNC_MSOP2SCHEMAOP_DECLARE(LRN)
FUNC_MSOP2SCHEMAOP_DECLARE(LshProjection)
FUNC_MSOP2SCHEMAOP_DECLARE(LSTM)
FUNC_MSOP2SCHEMAOP_DECLARE(L2NormalizeFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(MatMul)
FUNC_MSOP2SCHEMAOP_DECLARE(Maximum)
FUNC_MSOP2SCHEMAOP_DECLARE(MaximumGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Merge)
FUNC_MSOP2SCHEMAOP_DECLARE(Mfcc)
FUNC_MSOP2SCHEMAOP_DECLARE(Minimum)
FUNC_MSOP2SCHEMAOP_DECLARE(MinimumGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Mod)
FUNC_MSOP2SCHEMAOP_DECLARE(MulFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(MulGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Neg)
FUNC_MSOP2SCHEMAOP_DECLARE(NegGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(NotEqual)
FUNC_MSOP2SCHEMAOP_DECLARE(NonMaxSuppression)
FUNC_MSOP2SCHEMAOP_DECLARE(OneHot)
FUNC_MSOP2SCHEMAOP_DECLARE(OnesLike)
FUNC_MSOP2SCHEMAOP_DECLARE(PadFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(PartialFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(PowFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(PowerGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(PReLUFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(PriorBox)
FUNC_MSOP2SCHEMAOP_DECLARE(Proposal)
FUNC_MSOP2SCHEMAOP_DECLARE(Rank)
FUNC_MSOP2SCHEMAOP_DECLARE(Range)
FUNC_MSOP2SCHEMAOP_DECLARE(Rank)
FUNC_MSOP2SCHEMAOP_DECLARE(RealDiv)
FUNC_MSOP2SCHEMAOP_DECLARE(Reciprocal)
FUNC_MSOP2SCHEMAOP_DECLARE(ReduceFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Reshape)
FUNC_MSOP2SCHEMAOP_DECLARE(Resize)
FUNC_MSOP2SCHEMAOP_DECLARE(ReverseSequence)
FUNC_MSOP2SCHEMAOP_DECLARE(ReverseV2)
FUNC_MSOP2SCHEMAOP_DECLARE(Rfft)
FUNC_MSOP2SCHEMAOP_DECLARE(ROIPooling)
FUNC_MSOP2SCHEMAOP_DECLARE(Round)
FUNC_MSOP2SCHEMAOP_DECLARE(Rsqrt)
FUNC_MSOP2SCHEMAOP_DECLARE(QuantDTypeCast)
FUNC_MSOP2SCHEMAOP_DECLARE(Scale)
FUNC_MSOP2SCHEMAOP_DECLARE(ScaleFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(ScatterNd)
FUNC_MSOP2SCHEMAOP_DECLARE(Select)
FUNC_MSOP2SCHEMAOP_DECLARE(SGD)
FUNC_MSOP2SCHEMAOP_DECLARE(Shape)
FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogits)
FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogitsGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Sin)
FUNC_MSOP2SCHEMAOP_DECLARE(SkipGram)
FUNC_MSOP2SCHEMAOP_DECLARE(SliceFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1Loss)
FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1LossGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Softmax)
FUNC_MSOP2SCHEMAOP_DECLARE(SoftmaxCrossEntropyWithLogits)
FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatch)
FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatchND)
FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToDepth)
FUNC_MSOP2SCHEMAOP_DECLARE(SparseSoftmaxCrossEntropyWithLogits)
FUNC_MSOP2SCHEMAOP_DECLARE(SparseToDense)
FUNC_MSOP2SCHEMAOP_DECLARE(Split)
FUNC_MSOP2SCHEMAOP_DECLARE(Sqrt)
FUNC_MSOP2SCHEMAOP_DECLARE(Square)
FUNC_MSOP2SCHEMAOP_DECLARE(SquaredDifference)
FUNC_MSOP2SCHEMAOP_DECLARE(Squeeze)
FUNC_MSOP2SCHEMAOP_DECLARE(Stack)
FUNC_MSOP2SCHEMAOP_DECLARE(StridedSlice)
FUNC_MSOP2SCHEMAOP_DECLARE(Sub)
FUNC_MSOP2SCHEMAOP_DECLARE(SubFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(SubGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Switch)
FUNC_MSOP2SCHEMAOP_DECLARE(Tan)
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListFromTensor)
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListGetItem)
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListReserve)
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListSetItem)
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListStack)
FUNC_MSOP2SCHEMAOP_DECLARE(TileFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(TopKFusion)
FUNC_MSOP2SCHEMAOP_DECLARE(Transpose)
FUNC_MSOP2SCHEMAOP_DECLARE(Unique)
FUNC_MSOP2SCHEMAOP_DECLARE(UnsortedSegmentSum)
FUNC_MSOP2SCHEMAOP_DECLARE(Unsqueeze)
FUNC_MSOP2SCHEMAOP_DECLARE(Unstack)
FUNC_MSOP2SCHEMAOP_DECLARE(Where)
FUNC_MSOP2SCHEMAOP_DECLARE(ZerosLike)
FUNC_MSOP2SCHEMAOP_DECLARE(Select)
FUNC_MSOP2SCHEMAOP_DECLARE(GRU)
FUNC_MSOP2SCHEMAOP_DECLARE(NonZero)
FUNC_MSOP2SCHEMAOP_DECLARE(InvertPermutation)
FUNC_MSOP2SCHEMAOP_DECLARE(Size)
FUNC_MSOP2SCHEMAOP_DECLARE(RandomStandardNormal)
FUNC_MSOP2SCHEMAOP_DECLARE(CropAndResize)
FUNC_MSOP2SCHEMAOP_DECLARE(Erf)
FUNC_MSOP2SCHEMAOP_DECLARE(StridedSliceGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(IsFinite)
FUNC_MSOP2SCHEMAOP_DECLARE(LinSpace)
FUNC_MSOP2SCHEMAOP_DECLARE(UniformReal)
FUNC_MSOP2SCHEMAOP_DECLARE(AbsGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(RsqrtGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(SqrtGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(ResizeGrad)
FUNC_MSOP2SCHEMAOP_DECLARE(Splice)
FUNC_MSOP2SCHEMAOP_DECLARE(LogSoftmax)
FUNC_MSOP2SCHEMAOP_DECLARE(Call)
FUNC_MSOP2SCHEMAOP_DECLARE(CumSum)
FUNC_MSOP2SCHEMAOP_DECLARE(SplitWithOverlap)
#endif
} // namespace mindspore::lite::ops
#else
#define FUNC_MSOP2SCHEMAOP_DECLARE(OP)
#endif
#ifdef PRIMITIVE_WRITEABLE
FUNC_MSOP2SCHEMAOP_DECLARE(Abs);
FUNC_MSOP2SCHEMAOP_DECLARE(Activation);
FUNC_MSOP2SCHEMAOP_DECLARE(ActivationGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Adam);
FUNC_MSOP2SCHEMAOP_DECLARE(AddFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(AdderFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(AddGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(AddN);
FUNC_MSOP2SCHEMAOP_DECLARE(All);
FUNC_MSOP2SCHEMAOP_DECLARE(ApplyMomentum);
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMax);
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMaxFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMin);
FUNC_MSOP2SCHEMAOP_DECLARE(ArgMinFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Asin);
FUNC_MSOP2SCHEMAOP_DECLARE(Assert);
FUNC_MSOP2SCHEMAOP_DECLARE(Assign);
FUNC_MSOP2SCHEMAOP_DECLARE(AssignAdd);
FUNC_MSOP2SCHEMAOP_DECLARE(Atan);
FUNC_MSOP2SCHEMAOP_DECLARE(AudioSpectrogram);
FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(AvgPoolGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(BatchNorm);
FUNC_MSOP2SCHEMAOP_DECLARE(BatchNormGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpace);
FUNC_MSOP2SCHEMAOP_DECLARE(BatchToSpaceND);
FUNC_MSOP2SCHEMAOP_DECLARE(BiasAdd);
FUNC_MSOP2SCHEMAOP_DECLARE(BiasAddGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropy);
FUNC_MSOP2SCHEMAOP_DECLARE(BinaryCrossEntropyGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(BroadcastTo);
FUNC_MSOP2SCHEMAOP_DECLARE(Cast);
FUNC_MSOP2SCHEMAOP_DECLARE(Ceil);
FUNC_MSOP2SCHEMAOP_DECLARE(Clip);
FUNC_MSOP2SCHEMAOP_DECLARE(Concat);
FUNC_MSOP2SCHEMAOP_DECLARE(ControlDepend);
FUNC_MSOP2SCHEMAOP_DECLARE(ConstantOfShape);
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropFilterFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DBackpropInputFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2DFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Conv2dTransposeFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Cos);
FUNC_MSOP2SCHEMAOP_DECLARE(Crop);
FUNC_MSOP2SCHEMAOP_DECLARE(CustomExtractFeatures);
FUNC_MSOP2SCHEMAOP_DECLARE(CustomNormalize);
FUNC_MSOP2SCHEMAOP_DECLARE(CustomPredict);
FUNC_MSOP2SCHEMAOP_DECLARE(DeConv2DGradFilter);
FUNC_MSOP2SCHEMAOP_DECLARE(Depend);
FUNC_MSOP2SCHEMAOP_DECLARE(DepthToSpace);
FUNC_MSOP2SCHEMAOP_DECLARE(DetectionPostProcess);
FUNC_MSOP2SCHEMAOP_DECLARE(DivFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(DivGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Dropout);
FUNC_MSOP2SCHEMAOP_DECLARE(DropoutGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Eltwise);
FUNC_MSOP2SCHEMAOP_DECLARE(Elu);
FUNC_MSOP2SCHEMAOP_DECLARE(EmbeddingLookupFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Equal);
FUNC_MSOP2SCHEMAOP_DECLARE(ExpFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(ExpandDims);
FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVars);
FUNC_MSOP2SCHEMAOP_DECLARE(FakeQuantWithMinMaxVarsPerChannel);
FUNC_MSOP2SCHEMAOP_DECLARE(FftImag);
FUNC_MSOP2SCHEMAOP_DECLARE(FftReal);
FUNC_MSOP2SCHEMAOP_DECLARE(Fill);
FUNC_MSOP2SCHEMAOP_DECLARE(Flatten);
FUNC_MSOP2SCHEMAOP_DECLARE(FlattenGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Floor);
FUNC_MSOP2SCHEMAOP_DECLARE(FloorDiv);
FUNC_MSOP2SCHEMAOP_DECLARE(FloorMod);
FUNC_MSOP2SCHEMAOP_DECLARE(FullConnection);
FUNC_MSOP2SCHEMAOP_DECLARE(FusedBatchNorm);
FUNC_MSOP2SCHEMAOP_DECLARE(Gather);
FUNC_MSOP2SCHEMAOP_DECLARE(GatherNd);
FUNC_MSOP2SCHEMAOP_DECLARE(Greater);
FUNC_MSOP2SCHEMAOP_DECLARE(GreaterEqual);
FUNC_MSOP2SCHEMAOP_DECLARE(GroupConv2DGradInput);
FUNC_MSOP2SCHEMAOP_DECLARE(HashtableLookup);
FUNC_MSOP2SCHEMAOP_DECLARE(InstanceNorm);
FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(LeakyRelu);
FUNC_MSOP2SCHEMAOP_DECLARE(Less);
FUNC_MSOP2SCHEMAOP_DECLARE(LessEqual);
FUNC_MSOP2SCHEMAOP_DECLARE(Log);
FUNC_MSOP2SCHEMAOP_DECLARE(LogGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalAnd);
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalNot);
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalOr);
FUNC_MSOP2SCHEMAOP_DECLARE(LogicalXor);
FUNC_MSOP2SCHEMAOP_DECLARE(LpNormalization);
FUNC_MSOP2SCHEMAOP_DECLARE(LRN);
FUNC_MSOP2SCHEMAOP_DECLARE(LshProjection);
FUNC_MSOP2SCHEMAOP_DECLARE(LSTM);
FUNC_MSOP2SCHEMAOP_DECLARE(L2NormalizeFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(MatMul);
FUNC_MSOP2SCHEMAOP_DECLARE(Maximum);
FUNC_MSOP2SCHEMAOP_DECLARE(MaximumGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(MaxPoolGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Merge);
FUNC_MSOP2SCHEMAOP_DECLARE(Mfcc);
FUNC_MSOP2SCHEMAOP_DECLARE(Minimum);
FUNC_MSOP2SCHEMAOP_DECLARE(MinimumGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Mod);
FUNC_MSOP2SCHEMAOP_DECLARE(MulFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(MulGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Neg);
FUNC_MSOP2SCHEMAOP_DECLARE(NegGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(NotEqual);
FUNC_MSOP2SCHEMAOP_DECLARE(NonMaxSuppression);
FUNC_MSOP2SCHEMAOP_DECLARE(OneHot);
FUNC_MSOP2SCHEMAOP_DECLARE(OnesLike);
FUNC_MSOP2SCHEMAOP_DECLARE(PadFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(PartialFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(PowFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(PowerGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(PReLUFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(PriorBox);
FUNC_MSOP2SCHEMAOP_DECLARE(Proposal);
FUNC_MSOP2SCHEMAOP_DECLARE(Rank);
FUNC_MSOP2SCHEMAOP_DECLARE(Range);
FUNC_MSOP2SCHEMAOP_DECLARE(Rank);
FUNC_MSOP2SCHEMAOP_DECLARE(RealDiv);
FUNC_MSOP2SCHEMAOP_DECLARE(Reciprocal);
FUNC_MSOP2SCHEMAOP_DECLARE(ReduceFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Reshape);
FUNC_MSOP2SCHEMAOP_DECLARE(Resize);
FUNC_MSOP2SCHEMAOP_DECLARE(ReverseSequence);
FUNC_MSOP2SCHEMAOP_DECLARE(ReverseV2);
FUNC_MSOP2SCHEMAOP_DECLARE(Rfft);
FUNC_MSOP2SCHEMAOP_DECLARE(ROIPooling);
FUNC_MSOP2SCHEMAOP_DECLARE(Round);
FUNC_MSOP2SCHEMAOP_DECLARE(Rsqrt);
FUNC_MSOP2SCHEMAOP_DECLARE(QuantDTypeCast);
FUNC_MSOP2SCHEMAOP_DECLARE(Scale);
FUNC_MSOP2SCHEMAOP_DECLARE(ScaleFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(ScatterNd);
FUNC_MSOP2SCHEMAOP_DECLARE(Select);
FUNC_MSOP2SCHEMAOP_DECLARE(SGD);
FUNC_MSOP2SCHEMAOP_DECLARE(Shape);
FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogits);
FUNC_MSOP2SCHEMAOP_DECLARE(SigmoidCrossEntropyWithLogitsGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Sin);
FUNC_MSOP2SCHEMAOP_DECLARE(SkipGram);
FUNC_MSOP2SCHEMAOP_DECLARE(SliceFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1Loss);
FUNC_MSOP2SCHEMAOP_DECLARE(SmoothL1LossGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Softmax);
FUNC_MSOP2SCHEMAOP_DECLARE(SoftmaxCrossEntropyWithLogits);
FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatch);
FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToBatchND);
FUNC_MSOP2SCHEMAOP_DECLARE(SpaceToDepth);
FUNC_MSOP2SCHEMAOP_DECLARE(SparseSoftmaxCrossEntropyWithLogits);
FUNC_MSOP2SCHEMAOP_DECLARE(SparseToDense);
FUNC_MSOP2SCHEMAOP_DECLARE(Split);
FUNC_MSOP2SCHEMAOP_DECLARE(Sqrt);
FUNC_MSOP2SCHEMAOP_DECLARE(Square);
FUNC_MSOP2SCHEMAOP_DECLARE(SquaredDifference);
FUNC_MSOP2SCHEMAOP_DECLARE(Squeeze);
FUNC_MSOP2SCHEMAOP_DECLARE(Stack);
FUNC_MSOP2SCHEMAOP_DECLARE(StridedSlice);
FUNC_MSOP2SCHEMAOP_DECLARE(Sub);
FUNC_MSOP2SCHEMAOP_DECLARE(SubFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(SubGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Switch);
FUNC_MSOP2SCHEMAOP_DECLARE(Tan);
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListFromTensor);
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListGetItem);
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListReserve);
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListSetItem);
FUNC_MSOP2SCHEMAOP_DECLARE(TensorListStack);
FUNC_MSOP2SCHEMAOP_DECLARE(TileFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(TopKFusion);
FUNC_MSOP2SCHEMAOP_DECLARE(Transpose);
FUNC_MSOP2SCHEMAOP_DECLARE(Unique);
FUNC_MSOP2SCHEMAOP_DECLARE(UnsortedSegmentSum);
FUNC_MSOP2SCHEMAOP_DECLARE(Unsqueeze);
FUNC_MSOP2SCHEMAOP_DECLARE(Unstack);
FUNC_MSOP2SCHEMAOP_DECLARE(Where);
FUNC_MSOP2SCHEMAOP_DECLARE(ZerosLike);
FUNC_MSOP2SCHEMAOP_DECLARE(Select);
FUNC_MSOP2SCHEMAOP_DECLARE(GRU);
FUNC_MSOP2SCHEMAOP_DECLARE(NonZero);
FUNC_MSOP2SCHEMAOP_DECLARE(InvertPermutation);
FUNC_MSOP2SCHEMAOP_DECLARE(Size);
FUNC_MSOP2SCHEMAOP_DECLARE(RandomStandardNormal);
FUNC_MSOP2SCHEMAOP_DECLARE(CropAndResize);
FUNC_MSOP2SCHEMAOP_DECLARE(Erf);
FUNC_MSOP2SCHEMAOP_DECLARE(StridedSliceGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(IsFinite);
FUNC_MSOP2SCHEMAOP_DECLARE(LinSpace);
FUNC_MSOP2SCHEMAOP_DECLARE(UniformReal);
FUNC_MSOP2SCHEMAOP_DECLARE(AbsGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(RsqrtGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(SqrtGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(LayerNormGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(ResizeGrad);
FUNC_MSOP2SCHEMAOP_DECLARE(Splice);
FUNC_MSOP2SCHEMAOP_DECLARE(LogSoftmax);
FUNC_MSOP2SCHEMAOP_DECLARE(Call);
FUNC_MSOP2SCHEMAOP_DECLARE(CumSum);
FUNC_MSOP2SCHEMAOP_DECLARE(SplitWithOverlap);
#endif
#endif // MINDSPORE_LITE_SRC_OPS_OPS_FUNC_DECLARE_H_

373
mindspore/lite/src/ops/ops_utils.cc
View File

@ -15,6 +15,7 @@
*/
#include <memory>
#include <utility>
#include "src/ops/ops_utils.h"
#ifdef PRIMITIVE_WRITEABLE
@ -22,7 +23,7 @@
namespace mindspore {
namespace lite {
schema::PrimitiveT *GetPrimitiveT(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> GetPrimitiveT(const AnfNodePtr &node) {
auto prim = GetValueNode<std::shared_ptr<Primitive>>(node);
if (prim == nullptr) {
MS_LOG(DEBUG) << "primitive is nullptr";
@ -44,723 +45,723 @@ schema::PrimitiveT *GetPrimitiveT(const AnfNodePtr &node) {
}
}
schema::PrimitiveT *AbsPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AbsPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Abs>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AbsGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AbsGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AbsGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ActivationPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ActivationPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Activation>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ActivationGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ActivationGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ActivationGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AdamPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AdamPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Adam>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AdderFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AdderFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AdderFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AddFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AddFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AddFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AddGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AddGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AddGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AddNPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AddNPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AddN>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AllPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AllPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::All>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ApplyMomentumPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ApplyMomentumPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ApplyMomentum>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ArgMaxFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ArgMaxFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ArgMaxFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ArgMinFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ArgMinFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ArgMinFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AssertPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AssertPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Assert>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AssignPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AssignPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Assign>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AssignAddPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AssignAddPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AssignAdd>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AudioSpectrogramPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AudioSpectrogramPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AudioSpectrogram>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AvgPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AvgPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AvgPoolFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *AvgPoolGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> AvgPoolGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::AvgPoolGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *BatchNormPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> BatchNormPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchNorm>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *BatchToSpacePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> BatchToSpacePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchToSpace>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *BatchToSpaceNDPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> BatchToSpaceNDPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchToSpaceND>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *BiasAddPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> BiasAddPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BiasAdd>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *BiasAddGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> BiasAddGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BiasAddGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *BNGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> BNGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BatchNormGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *BroadcastToPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> BroadcastToPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::BroadcastTo>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CastPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CastPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Cast>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CeilPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CeilPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Ceil>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ClipPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ClipPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Clip>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ConcatPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ConcatPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Concat>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ConstantOfShapePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ConstantOfShapePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ConstantOfShape>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ControlDependPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ControlDependPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ControlDepend>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *Conv2DBackpropFilterFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> Conv2DBackpropFilterFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2DBackpropFilterFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *Conv2DBackpropInputFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> Conv2DBackpropInputFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2DBackpropInputFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *Conv2DFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> Conv2DFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2DFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *Conv2dTransposeFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> Conv2dTransposeFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Conv2dTransposeFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CosPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CosPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Cos>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CropPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CropPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Crop>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CropAndResizePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CropAndResizePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CropAndResize>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CustomExtractFeaturesPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CustomExtractFeaturesPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CustomExtractFeatures>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CustomNormalizePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CustomNormalizePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CustomNormalize>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CustomPredictPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CustomPredictPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CustomPredict>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *DependPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> DependPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Depend>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *DepthToSpacePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> DepthToSpacePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DepthToSpace>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *DetectionPostProcessPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> DetectionPostProcessPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DetectionPostProcess>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *DivFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> DivFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DivFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *DivGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> DivGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DivGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *DropoutPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> DropoutPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Dropout>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *DropoutGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> DropoutGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::DropoutGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *GRUPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> GRUPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::GRU>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *EltwisePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> EltwisePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Eltwise>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *EluPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> EluPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Elu>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *EmbeddingLookupFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> EmbeddingLookupFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::EmbeddingLookupFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *EqualPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> EqualPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Equal>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ExpandDimsPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ExpandDimsPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ExpandDims>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ExpFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ExpFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ExpFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FftImagPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FftImagPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FftImag>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FftRealPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FftRealPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FftReal>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FillPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FillPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Fill>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FlattenPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FlattenPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Flatten>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FlattenGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FlattenGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FlattenGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FloorPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FloorPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Floor>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FloorDivPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FloorDivPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FloorDiv>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FloorModPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FloorModPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FloorMod>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FullConnectionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FullConnectionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FullConnection>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *FusedBatchNormPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> FusedBatchNormPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::FusedBatchNorm>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *GatherPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> GatherPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Gather>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *GatherNdPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> GatherNdPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::GatherNd>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *GreaterPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> GreaterPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Greater>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *GreaterEqualPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> GreaterEqualPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::GreaterEqual>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *HashtableLookupPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> HashtableLookupPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::HashtableLookup>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *InstanceNormPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> InstanceNormPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::InstanceNorm>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *InvertPermutationPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> InvertPermutationPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::InvertPermutation>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LayerNormFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LayerNormFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LayerNormFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LayerNormGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LayerNormGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LayerNormGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LeakyReluPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LeakyReluPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LeakyRelu>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LessPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LessPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Less>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LessEqualPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LessEqualPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LessEqual>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LogPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LogPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Log>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LogGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LogGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LogicalAndPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LogicalAndPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogicalAnd>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LogicalNotPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LogicalNotPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogicalNot>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LogicalOrPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LogicalOrPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogicalOr>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LrnPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LrnPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LRN>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LpNormalizationPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LpNormalizationPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LpNormalization>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LshProjectionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LshProjectionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LshProjection>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LSTMPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LSTMPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LSTM>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *L2NormalizeFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> L2NormalizeFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::L2NormalizeFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MatMulPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MatMulPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MatMul>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MaximumPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MaximumPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Maximum>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MaximumGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MaximumGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MaximumGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MaxPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MaxPoolFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MaxPoolFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MaxPoolGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MaxPoolGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MaxPoolGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MergePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MergePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Merge>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MfccPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MfccPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Mfcc>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MinimumPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MinimumPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Minimum>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MinimumGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MinimumGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MinimumGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ModPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ModPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Mod>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MulFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MulFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MulFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *MulGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> MulGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::MulGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *NegPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> NegPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Neg>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *NegGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> NegGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::NegGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *NotEqualPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> NotEqualPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::NotEqual>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *NonMaxSuppressionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> NonMaxSuppressionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::NonMaxSuppression>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *OneHotPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> OneHotPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::OneHot>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *OnesLikePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> OnesLikePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::OnesLike>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *PadFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> PadFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PadFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *PartialFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> PartialFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PartialFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *PowerGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> PowerGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PowerGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *PowFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> PowFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PowFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *PReLUFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> PReLUFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::PReLUFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *QuantDTypeCastPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> QuantDTypeCastPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::QuantDTypeCast>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RangePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RangePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Range>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RandomStandardNormalPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RandomStandardNormalPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::RandomStandardNormal>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RankPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RankPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Rank>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RealDivPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RealDivPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::RealDiv>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ReciprocalPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ReciprocalPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Reciprocal>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ReduceFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ReduceFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ReduceFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ReshapePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ReshapePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Reshape>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ResizePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ResizePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Resize>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ResizeGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ResizeGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ResizeGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ReverseV2PrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ReverseV2PrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ReverseV2>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ReverseSequencePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ReverseSequencePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ReverseSequence>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RfftPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RfftPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Rfft>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ROIPoolingPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ROIPoolingPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ROIPooling>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RoundPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RoundPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Round>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RsqrtPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RsqrtPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Rsqrt>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *RsqrtGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> RsqrtGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::RsqrtGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ScaleFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ScaleFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ScaleFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ScatterNdPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ScatterNdPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ScatterNd>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SelectPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SelectPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Select>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SGDPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SGDPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SGD>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ShapePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ShapePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Shape>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SigmoidCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SigmoidCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SigmoidCrossEntropyWithLogits>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SigmoidCrossEntropyWithLogitsGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SigmoidCrossEntropyWithLogitsGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SigmoidCrossEntropyWithLogitsGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SinPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SinPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Sin>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SizePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SizePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Size>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SkipGramPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SkipGramPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SkipGram>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SliceFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SliceFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SliceFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SmoothL1LossPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SmoothL1LossPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SmoothL1Loss>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SmoothL1LossGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SmoothL1LossGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SmoothL1LossGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SoftmaxPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SoftmaxPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Softmax>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SoftmaxCrossEntropyWithLogits>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SpaceToBatchPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SpaceToBatchPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SpaceToBatch>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SpaceToBatchNDPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SpaceToBatchNDPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SpaceToBatchND>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SpaceToDepthPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SpaceToDepthPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SpaceToDepth>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SparseSoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SparseSoftmaxCrossEntropyWithLogitsPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SparseSoftmaxCrossEntropyWithLogits>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SparseToDensePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SparseToDensePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SparseToDense>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SplitPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SplitPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Split>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SqrtPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SqrtPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Sqrt>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SqrtGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SqrtGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SqrtGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SquarePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SquarePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Square>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SquaredDifferencePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SquaredDifferencePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SquaredDifference>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SqueezePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SqueezePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Squeeze>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *StackPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> StackPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Stack>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *StridedSlicePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> StridedSlicePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::StridedSlice>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *StridedSliceGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> StridedSliceGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::StridedSliceGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SubFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SubFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SubFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SubGradPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SubGradPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::SubGrad>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SwitchPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SwitchPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Switch>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TensorListFromTensorPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TensorListFromTensorPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListFromTensor>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TensorListGetItemPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TensorListGetItemPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListGetItem>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TensorListReservePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TensorListReservePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListReserve>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TensorListSetItemPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TensorListSetItemPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListSetItem>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TensorListStackPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TensorListStackPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TensorListStack>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TileFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TileFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TileFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TopKFusionPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TopKFusionPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::TopKFusion>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *TransposePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> TransposePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Transpose>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *UniquePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> UniquePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Unique>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *UnstackPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> UnstackPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Unstack>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *UnsortedSegmentSumPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> UnsortedSegmentSumPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::UnsortedSegmentSum>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *UnsqueezePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> UnsqueezePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Unsqueeze>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *WherePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> WherePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Where>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ZerosLikePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ZerosLikePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::ZerosLike>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *ErfPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> ErfPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Erf>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *SplicePrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> SplicePrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Splice>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *LogSoftmaxPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> LogSoftmaxPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::LogSoftmax>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CallPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CallPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Call>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
schema::PrimitiveT *CumSumPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CumSumPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::CumSum>>(node);
return ms_primc != nullptr ? ops::MSOp2SchemaOp(ms_primc.get()) : nullptr;
}
@ -982,9 +983,9 @@ RegistryMSOps g_LogSoftmaxPrimitiveCreatorRegistry("LogSoftmax", LogSoftmaxPrimi
RegistryMSOps g_CallPrimitiveCreatorRegistry("call", CallPrimitiveCreator);
RegistryMSOps g_CumSumPrimitiveCreatorRegistry("CumSum", CumSumPrimitiveCreator);
schema::PrimitiveT *CustomPrimitiveCreator(const AnfNodePtr &node) {
std::unique_ptr<schema::PrimitiveT> CustomPrimitiveCreator(const AnfNodePtr &node) {
auto ms_primc = GetValueNode<std::shared_ptr<mindspore::ops::Custom>>(node);
auto *schema_op = new (std::nothrow) schema::CustomT();
auto schema_op = std::make_unique<schema::CustomT>();
if (schema_op == nullptr) {
return nullptr;
}
@ -994,21 +995,21 @@ schema::PrimitiveT *CustomPrimitiveCreator(const AnfNodePtr &node) {
if (ms_primc->GetAttr("attr") != nullptr) {
auto attr_map = ms_primc->get_attr();
for (const auto &attr_item : attr_map) {
auto *attr = new (std::nothrow) schema::AttributeT();
auto attr = std::make_unique<schema::AttributeT>();
if (attr == nullptr) {
return nullptr;
}
attr->name = attr_item.first;
attr->data = attr_item.second;
schema_op->attr.emplace_back(attr);
schema_op->attr.emplace_back(std::move(attr));
}
}
auto *prim = new (std::nothrow) schema::PrimitiveT();
auto prim = std::make_unique<schema::PrimitiveT>();
if (prim == nullptr) {
return nullptr;
}
prim->value.value = schema_op;
prim->value.value = schema_op.release();
prim->value.type = schema::PrimitiveType_Custom;
return prim;
}

11
mindspore/lite/src/ops/ops_utils.h
View File

@ -19,12 +19,13 @@
#include <map>
#include <string>
#include <memory>
#include "src/ops/ops_func_declare.h"
#ifdef PRIMITIVE_WRITEABLE
namespace mindspore {
namespace lite {
typedef schema::PrimitiveT *(*PrimitiveTCreator)(const AnfNodePtr &node);
typedef std::unique_ptr<schema::PrimitiveT> (*PrimitiveTCreator)(const AnfNodePtr &node);
class MSOpsRegistry {
public:
@ -32,8 +33,8 @@ class MSOpsRegistry {
static MSOpsRegistry registry;
return &registry;
}
void InsertPrimitiveTMap(std::string name, PrimitiveTCreator creator) { primitive_creators[name] = creator; }
PrimitiveTCreator GetPrimitiveCreator(std::string name) {
void InsertPrimitiveTMap(const std::string &name, PrimitiveTCreator creator) { primitive_creators[name] = creator; }
PrimitiveTCreator GetPrimitiveCreator(const std::string &name) {
if (primitive_creators.find(name) != primitive_creators.end()) {
return primitive_creators[name];
} else {
@ -48,13 +49,13 @@ class MSOpsRegistry {
class RegistryMSOps {
public:
RegistryMSOps(std::string name, PrimitiveTCreator creator) {
RegistryMSOps(const std::string &name, PrimitiveTCreator creator) {
MSOpsRegistry::GetInstance()->InsertPrimitiveTMap(name, creator);
}
~RegistryMSOps() = default;
};
schema::PrimitiveT *GetPrimitiveT(const mindspore::AnfNodePtr &node);
std::unique_ptr<schema::PrimitiveT> GetPrimitiveT(const mindspore::AnfNodePtr &node);
} // namespace lite
} // namespace mindspore
#endif

7
mindspore/lite/tools/anf_exporter/anf_exporter.cc
View File

@ -21,9 +21,7 @@
#include <functional>
#include <utility>
#include <vector>
#include <algorithm>
#include "tools/converter/converter_flags.h"
#include "tools/common/tensor_util.h"
#include "abstract/abstract_value.h"
#include "mindspore/core/ir/primitive.h"
#include "mindspore/core/ops/op_utils.h"
@ -35,7 +33,6 @@
#include "tools/optimizer/common/gllo_utils.h"
#include "tools/converter/quantizer/bitpacking.h"
#include "src/common/utils.h"
#include "ops/op_utils.h"
#include "tools/common/graph_util.h"
#include "src/ops/ops_utils.h"
#include "tools/common/node_util.h"
@ -286,7 +283,7 @@ int AnfExporter::Anf2Fb(const FuncGraphPtr &func_graph, const std::unique_ptr<sc
auto cnodes = GetOrderedCNodes(func_graph);
for (const auto &cnode : cnodes) {
auto prim = GetValueNode<std::shared_ptr<Primitive>>(cnode->input(0));
schema::PrimitiveT *primT = nullptr;
std::unique_ptr<schema::PrimitiveT> primT;
if (prim == nullptr) {
auto fg = GetValueNode<FuncGraphPtr>(cnode->input(0));
if (fg != nullptr) {
@ -344,7 +341,7 @@ int AnfExporter::Anf2Fb(const FuncGraphPtr &func_graph, const std::unique_ptr<sc
primT = GetPrimitiveT(cnode->input(0));
}
node->name = cnode->fullname_with_scope();
node->primitive = std::unique_ptr<schema::PrimitiveT>(primT);
node->primitive = std::move(primT);
auto device_type_attr = cnode->GetAttr(mindspore::ops::kDeviceType);
node->deviceType = (device_type_attr != nullptr) ? GetValue<int32_t>(device_type_attr) : -1;
ret = SetOpInputNode(cnode, meta_graphT, node.get());

4
mindspore/lite/tools/optimizer/fusion/constant_folding_fusion.cc
View File

@ -146,8 +146,8 @@ kernel::LiteKernel *GetLiteKernel(std::vector<Tensor *> inputs, std::vector<Tens
MS_ASSERT(cnode != nullptr && context != nullptr);
auto prim_t = lite::GetPrimitiveT(cnode->input(0));
flatbuffers::FlatBufferBuilder fbb(INITIAL_SIZE);
auto prim = lite::ConvertToPrimitive(prim_t, &fbb);
delete prim_t;
auto prim = lite::ConvertToPrimitive(prim_t.release(), &fbb);
prim_t.reset();
if (prim == nullptr) {
fbb.Clear();
MS_LOG(ERROR) << "get primitive failed.";

4
mindspore/lite/tools/optimizer/graph/infershape_pass.cc
View File

@ -400,8 +400,8 @@ bool InferShapePass::Run(const FuncGraphPtr &func_graph) {
}
flatbuffers::FlatBufferBuilder fbb(INITIAL_SIZE);
auto prim = lite::ConvertToPrimitive(prim_t, &fbb);
delete prim_t;
auto prim = lite::ConvertToPrimitive(prim_t.release(), &fbb);
prim_t.reset();
if (prim == nullptr) {
MS_LOG(ERROR) << "get primitive failed.";
FreeTensors(&input_tensors);

6
mindspore/lite/tools/optimizer/graph/node_infershape.cc
View File

@ -117,7 +117,7 @@ bool NodeInferShape::JudgeOpSupportInfer(const CNodePtr &cnode) {
}
auto parameter_gen = lite::PopulateRegistry::GetInstance()->GetParameterCreator(prim_t->value.type, lite::SCHEMA_CUR);
if (parameter_gen == nullptr) {
delete prim_t;
prim_t.reset();
return false;
}
return true;
@ -153,8 +153,8 @@ STATUS NodeInferShape::InferShape(const CNodePtr &cnode) {
return lite::RET_ERROR;
}
flatbuffers::FlatBufferBuilder fbb(INITIAL_SIZE);
auto prim = lite::ConvertToPrimitive(prim_t, &fbb);
delete prim_t;
auto prim = lite::ConvertToPrimitive(prim_t.release(), &fbb);
prim_t.reset();
if (prim == nullptr) {
MS_LOG(ERROR) << "get primitive failed.";
FreeTensors(&inputs);