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

codedex

This commit is contained in:
yefeng 2021-04-25 14:40:08 +08:00
parent 552800e03a
commit 6a8e5adbf3
60 changed files with 190 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
mindspore/lite/tools/converter/parser/tflite/tflite_activation_parser.h
View File

@ -29,6 +29,8 @@ class TfliteReluParser : public TfliteNodeParser {
public:
TfliteReluParser() : TfliteNodeParser("Relu") {}
~TfliteReluParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -37,6 +39,8 @@ class TfliteRelu6Parser : public TfliteNodeParser {
public:
TfliteRelu6Parser() : TfliteNodeParser("Relu6") {}
~TfliteRelu6Parser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -45,6 +49,8 @@ class TfliteLeakyReluParser : public TfliteNodeParser {
public:
TfliteLeakyReluParser() : TfliteNodeParser("LeakyRelu") {}
~TfliteLeakyReluParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -53,6 +59,8 @@ class TflitePReLUParser : public TfliteNodeParser {
public:
TflitePReLUParser() : TfliteNodeParser("PReLU") {}
~TflitePReLUParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -61,6 +69,8 @@ class TfliteTanhParser : public TfliteNodeParser {
public:
TfliteTanhParser() : TfliteNodeParser("Tanh") {}
~TfliteTanhParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -69,6 +79,8 @@ class TfliteHardSwishParser : public TfliteNodeParser {
public:
TfliteHardSwishParser() : TfliteNodeParser("HardSwish") {}
~TfliteHardSwishParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -77,6 +89,8 @@ class TfliteLogisticParser : public TfliteNodeParser {
public:
TfliteLogisticParser() : TfliteNodeParser("Logistic") {}
~TfliteLogisticParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_addn_parser.h
View File

@ -29,6 +29,8 @@ class TfliteAddNParser : public TfliteNodeParser {
public:
TfliteAddNParser() : TfliteNodeParser("AddN") {}
~TfliteAddNParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_argmax_parser.h
View File

@ -29,6 +29,8 @@ class TfliteArgmaxParser : public TfliteNodeParser {
public:
TfliteArgmaxParser() : TfliteNodeParser("Argmax") {}
~TfliteArgmaxParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_argmin_parser.h
View File

@ -29,6 +29,8 @@ class TfliteArgminParser : public TfliteNodeParser {
public:
TfliteArgminParser() : TfliteNodeParser("Argmin") {}
~TfliteArgminParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

56
mindspore/lite/tools/converter/parser/tflite/tflite_arithmetic_parser.h
View File

@ -29,6 +29,8 @@ class TfliteAddParser : public TfliteNodeParser {
public:
TfliteAddParser() : TfliteNodeParser("Add") {}
~TfliteAddParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -37,6 +39,8 @@ class TfliteSubParser : public TfliteNodeParser {
public:
TfliteSubParser() : TfliteNodeParser("Sub") {}
~TfliteSubParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -45,6 +49,8 @@ class TfliteMulParser : public TfliteNodeParser {
public:
TfliteMulParser() : TfliteNodeParser("Mul") {}
~TfliteMulParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -53,6 +59,8 @@ class TfliteDivParser : public TfliteNodeParser {
public:
TfliteDivParser() : TfliteNodeParser("Div") {}
~TfliteDivParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -61,6 +69,8 @@ class TfliteFloorDivParser : public TfliteNodeParser {
public:
TfliteFloorDivParser() : TfliteNodeParser("FloorDiv") {}
~TfliteFloorDivParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -69,6 +79,8 @@ class TfliteFloorModParser : public TfliteNodeParser {
public:
TfliteFloorModParser() : TfliteNodeParser("FloorMod") {}
~TfliteFloorModParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -77,6 +89,8 @@ class TflitePowParser : public TfliteNodeParser {
public:
TflitePowParser() : TfliteNodeParser("PowFusion") {}
~TflitePowParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -85,6 +99,8 @@ class TfliteSquaredDifferenceParser : public TfliteNodeParser {
public:
TfliteSquaredDifferenceParser() : TfliteNodeParser("SquaredDifference") {}
~TfliteSquaredDifferenceParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -93,6 +109,8 @@ class TfliteMaximumParser : public TfliteNodeParser {
public:
TfliteMaximumParser() : TfliteNodeParser("Maximum") {}
~TfliteMaximumParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -101,6 +119,8 @@ class TfliteMinimumParser : public TfliteNodeParser {
public:
TfliteMinimumParser() : TfliteNodeParser("Minimum") {}
~TfliteMinimumParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -109,6 +129,8 @@ class TfliteAbsParser : public TfliteNodeParser {
public:
TfliteAbsParser() : TfliteNodeParser("Abs") {}
~TfliteAbsParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -117,6 +139,8 @@ class TfliteExpParser : public TfliteNodeParser {
public:
TfliteExpParser() : TfliteNodeParser("Exp") {}
~TfliteExpParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -125,6 +149,8 @@ class TfliteSqrtParser : public TfliteNodeParser {
public:
TfliteSqrtParser() : TfliteNodeParser("Sqrt") {}
~TfliteSqrtParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -133,6 +159,8 @@ class TfliteRsqrtParser : public TfliteNodeParser {
public:
TfliteRsqrtParser() : TfliteNodeParser("Rsqrt") {}
~TfliteRsqrtParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -141,6 +169,8 @@ class TfliteSquareParser : public TfliteNodeParser {
public:
TfliteSquareParser() : TfliteNodeParser("Square") {}
~TfliteSquareParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -149,6 +179,8 @@ class TfliteSinParser : public TfliteNodeParser {
public:
TfliteSinParser() : TfliteNodeParser("Sin") {}
~TfliteSinParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -157,6 +189,8 @@ class TfliteCosParser : public TfliteNodeParser {
public:
TfliteCosParser() : TfliteNodeParser("Cos") {}
~TfliteCosParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -165,6 +199,8 @@ class TfliteLogParser : public TfliteNodeParser {
public:
TfliteLogParser() : TfliteNodeParser("Log") {}
~TfliteLogParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -173,6 +209,8 @@ class TfliteRoundParser : public TfliteNodeParser {
public:
TfliteRoundParser() : TfliteNodeParser("Round") {}
~TfliteRoundParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -181,6 +219,8 @@ class TfliteCeilParser : public TfliteNodeParser {
public:
TfliteCeilParser() : TfliteNodeParser("Ceil") {}
~TfliteCeilParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -189,6 +229,8 @@ class TfliteFloorParser : public TfliteNodeParser {
public:
TfliteFloorParser() : TfliteNodeParser("Floor") {}
~TfliteFloorParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -197,6 +239,8 @@ class TfliteNegParser : public TfliteNodeParser {
public:
TfliteNegParser() : TfliteNodeParser("Neg") {}
~TfliteNegParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -205,6 +249,8 @@ class TfliteEqualParser : public TfliteNodeParser {
public:
TfliteEqualParser() : TfliteNodeParser("Equal") {}
~TfliteEqualParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -213,6 +259,8 @@ class TfliteNotEqualParser : public TfliteNodeParser {
public:
TfliteNotEqualParser() : TfliteNodeParser("NotEqual") {}
~TfliteNotEqualParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -221,6 +269,8 @@ class TfliteGreaterParser : public TfliteNodeParser {
public:
TfliteGreaterParser() : TfliteNodeParser("Greater") {}
~TfliteGreaterParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -229,6 +279,8 @@ class TfliteGreaterEqualParser : public TfliteNodeParser {
public:
TfliteGreaterEqualParser() : TfliteNodeParser("GreaterEqual") {}
~TfliteGreaterEqualParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -237,6 +289,8 @@ class TfliteLessParser : public TfliteNodeParser {
public:
TfliteLessParser() : TfliteNodeParser("Less") {}
~TfliteLessParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -245,6 +299,8 @@ class TfliteLessEqualParser : public TfliteNodeParser {
public:
TfliteLessEqualParser() : TfliteNodeParser("LessEqual") {}
~TfliteLessEqualParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_batch_to_space_parser.h
View File

@ -29,6 +29,8 @@ class TfliteBatchToSpaceParser : public TfliteNodeParser {
public:
TfliteBatchToSpaceParser() : TfliteNodeParser("BatchToSpace") {}
~TfliteBatchToSpaceParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_broadcast_to_parser.h
View File

@ -29,6 +29,8 @@ class TfliteBroadcastToParser : public TfliteNodeParser {
public:
TfliteBroadcastToParser() : TfliteNodeParser("BroadcastTo") {}
~TfliteBroadcastToParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_cast_parser.h
View File

@ -29,6 +29,8 @@ class TfliteCastParser : public TfliteNodeParser {
public:
TfliteCastParser() : TfliteNodeParser("Cast") {}
~TfliteCastParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_concat_parser.h
View File

@ -29,6 +29,8 @@ class TfliteConcatParser : public TfliteNodeParser {
public:
TfliteConcatParser() : TfliteNodeParser("Concat") {}
~TfliteConcatParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

4
mindspore/lite/tools/converter/parser/tflite/tflite_conv_parser.h
View File

@ -29,6 +29,8 @@ class TfliteConvParser : public TfliteNodeParser {
public:
TfliteConvParser() : TfliteNodeParser("Conv2D") {}
~TfliteConvParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -37,6 +39,8 @@ class TfliteDepthwiseConv2DParser : public TfliteNodeParser {
public:
TfliteDepthwiseConv2DParser() : TfliteNodeParser("DepthwiseConv2D") {}
~TfliteDepthwiseConv2DParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_conv_transpose_parser.h
View File

@ -29,6 +29,8 @@ class TfliteDeConvParser : public TfliteNodeParser {
public:
TfliteDeConvParser() : TfliteNodeParser("DeConv2D") {}
~TfliteDeConvParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_custom_parser.h
View File

@ -29,6 +29,8 @@ class TfliteCustomParser : public TfliteNodeParser {
public:
TfliteCustomParser() : TfliteNodeParser("Custom") {}
~TfliteCustomParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;

2
mindspore/lite/tools/converter/parser/tflite/tflite_depth_to_space_parser.h
View File

@ -29,6 +29,8 @@ class TfliteDepthToSpaceParser : public TfliteNodeParser {
public:
TfliteDepthToSpaceParser() : TfliteNodeParser("DepthToSpace") {}
~TfliteDepthToSpaceParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_dequantize_parser.h
View File

@ -28,6 +28,8 @@ class TfliteDequantizeParser : public TfliteNodeParser {
public:
TfliteDequantizeParser() : TfliteNodeParser("Dequantize") {}
~TfliteDequantizeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_expand_dims_parser.h
View File

@ -29,6 +29,8 @@ class TfliteExpandDimsParser : public TfliteNodeParser {
public:
TfliteExpandDimsParser() : TfliteNodeParser("ExpandDims") {}
~TfliteExpandDimsParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_fill_parser.h
View File

@ -29,6 +29,8 @@ class TfliteFillParser : public TfliteNodeParser {
public:
TfliteFillParser() : TfliteNodeParser("Fill") {}
~TfliteFillParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_fullyconnected_parser.h
View File

@ -29,6 +29,8 @@ class TfliteFullyConnectedParser : public TfliteNodeParser {
public:
TfliteFullyConnectedParser() : TfliteNodeParser("FullyConnected") {}
~TfliteFullyConnectedParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_gather_nd_parser.h
View File

@ -29,6 +29,8 @@ class TfliteGatherNdParser : public TfliteNodeParser {
public:
TfliteGatherNdParser() : TfliteNodeParser("GatherND") {}
~TfliteGatherNdParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_gather_parser.h
View File

@ -29,6 +29,8 @@ class TfliteGatherParser : public TfliteNodeParser {
public:
TfliteGatherParser() : TfliteNodeParser("Gather") {}
~TfliteGatherParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_hashtable_lookup_parser.h
View File

@ -29,6 +29,8 @@ class TfliteHashtableLookupParser : public TfliteNodeParser {
public:
TfliteHashtableLookupParser() : TfliteNodeParser("HashtableLookup") {}
~TfliteHashtableLookupParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_l2norm_parser.h
View File

@ -29,6 +29,8 @@ class TfliteL2NormParser : public TfliteNodeParser {
public:
TfliteL2NormParser() : TfliteNodeParser("L2_NORMALIZATION") {}
~TfliteL2NormParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_logical_parser.h
View File

@ -29,6 +29,8 @@ class TfliteLogicalAndParser : public TfliteNodeParser {
public:
TfliteLogicalAndParser() : TfliteNodeParser("LogicalAnd") {}
~TfliteLogicalAndParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_lrn_parser.h
View File

@ -29,6 +29,8 @@ class TfliteLRNParser : public TfliteNodeParser {
public:
TfliteLRNParser() : TfliteNodeParser("LocalResponseNorm") {}
~TfliteLRNParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_lsh_projection_parser.h
View File

@ -29,6 +29,8 @@ class TfliteLshProjectionParser : public TfliteNodeParser {
public:
TfliteLshProjectionParser() : TfliteNodeParser("LshProjection") {}
~TfliteLshProjectionParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_matmul_parser.h
View File

@ -28,6 +28,8 @@ class TfliteMatMulParser : public TfliteNodeParser {
public:
TfliteMatMulParser() : TfliteNodeParser("MatMul") {}
~TfliteMatMulParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h
View File

@ -42,6 +42,8 @@ class TfliteNodeRegister {
TfliteNodeRegister(const tflite::BuiltinOperator &type, TfliteNodeParser *parser) {
TfliteNodeParserRegistry::GetInstance()->parsers[type] = parser;
}
~TfliteNodeRegister() = default;
};
} // namespace lite
} // namespace mindspore

2
mindspore/lite/tools/converter/parser/tflite/tflite_one_hot_parser.h
View File

@ -29,6 +29,8 @@ class TfliteOneHotParser : public TfliteNodeParser {
public:
TfliteOneHotParser() : TfliteNodeParser("OneHot") {}
~TfliteOneHotParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_pad_parser.h
View File

@ -29,6 +29,8 @@ class TflitePadParser : public TfliteNodeParser {
public:
TflitePadParser() : TfliteNodeParser("Pad") {}
~TflitePadParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

4
mindspore/lite/tools/converter/parser/tflite/tflite_pooling_parser.h
View File

@ -29,6 +29,8 @@ class TfliteAvgPoolParser : public TfliteNodeParser {
public:
TfliteAvgPoolParser() : TfliteNodeParser("avg_pool") {}
~TfliteAvgPoolParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};
@ -37,6 +39,8 @@ class TfliteMaxPoolParser : public TfliteNodeParser {
public:
TfliteMaxPoolParser() : TfliteNodeParser("max_pool") {}
~TfliteMaxPoolParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_quantize_parser.h
View File

@ -28,6 +28,8 @@ class TfliteQuantizeParser : public TfliteNodeParser {
public:
TfliteQuantizeParser() : TfliteNodeParser("Quantize") {}
~TfliteQuantizeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_range_parser.h
View File

@ -29,6 +29,8 @@ class TfliteRangeParser : public TfliteNodeParser {
public:
TfliteRangeParser() : TfliteNodeParser("Range") {}
~TfliteRangeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_rank_parser.h
View File

@ -29,6 +29,8 @@ class TfliteRankParser : public TfliteNodeParser {
public:
TfliteRankParser() : TfliteNodeParser("Rank") {}
~TfliteRankParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_reduce_parser.h
View File

@ -28,6 +28,8 @@ class TfliteReduceParser : public TfliteNodeParser {
public:
TfliteReduceParser() : TfliteNodeParser("node_name") {}
~TfliteReduceParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_reshape_parser.h
View File

@ -29,6 +29,8 @@ class TfliteReshapeParser : public TfliteNodeParser {
public:
TfliteReshapeParser() : TfliteNodeParser("Reshape") {}
~TfliteReshapeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_resize_parser.h
View File

@ -28,6 +28,8 @@ class TfliteResizeParser : public TfliteNodeParser {
public:
TfliteResizeParser() : TfliteNodeParser("resize_bilinear") {}
~TfliteResizeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_reverse_parser.h
View File

@ -29,6 +29,8 @@ class TfliteReverseParser : public TfliteNodeParser {
public:
TfliteReverseParser() : TfliteNodeParser("reverse") {}
~TfliteReverseParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_reverse_sequence_parser.h
View File

@ -29,6 +29,8 @@ class TfliteReverseSequenceParser : public TfliteNodeParser {
public:
TfliteReverseSequenceParser() : TfliteNodeParser("ReverseSequence") {}
~TfliteReverseSequenceParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_scatter_nd_parser.h
View File

@ -29,6 +29,8 @@ class TfliteScatterNdParser : public TfliteNodeParser {
public:
TfliteScatterNdParser() : TfliteNodeParser("ScatterNd") {}
~TfliteScatterNdParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_shape_parser.h
View File

@ -29,6 +29,8 @@ class TfliteShapeParser : public TfliteNodeParser {
public:
TfliteShapeParser() : TfliteNodeParser("Shape") {}
~TfliteShapeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_skip_gram_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSkipGramParser : public TfliteNodeParser {
public:
TfliteSkipGramParser() : TfliteNodeParser("SkipGram") {}
~TfliteSkipGramParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_slice_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSliceParser : public TfliteNodeParser {
public:
TfliteSliceParser() : TfliteNodeParser("Slice") {}
~TfliteSliceParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_softmax_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSoftmaxParser : public TfliteNodeParser {
public:
TfliteSoftmaxParser() : TfliteNodeParser("Softmax") {}
~TfliteSoftmaxParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_space_to_batch_nd_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSpaceToBatchNDParser : public TfliteNodeParser {
public:
TfliteSpaceToBatchNDParser() : TfliteNodeParser("SpaceToBatchND") {}
~TfliteSpaceToBatchNDParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_space_to_depth_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSpaceToDepthParser : public TfliteNodeParser {
public:
TfliteSpaceToDepthParser() : TfliteNodeParser("SpaceToDepth") {}
~TfliteSpaceToDepthParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_sparse_to_dense_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSparseToDenseParser : public TfliteNodeParser {
public:
TfliteSparseToDenseParser() : TfliteNodeParser("SparseToDense") {}
~TfliteSparseToDenseParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_split_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSplitParser : public TfliteNodeParser {
public:
TfliteSplitParser() : TfliteNodeParser("Split") {}
~TfliteSplitParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_split_v_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSplitVParser : public TfliteNodeParser {
public:
TfliteSplitVParser() : TfliteNodeParser("SplitV") {}
~TfliteSplitVParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_squeeze_parser.h
View File

@ -29,6 +29,8 @@ class TfliteSqueezeParser : public TfliteNodeParser {
public:
TfliteSqueezeParser() : TfliteNodeParser("Squeeze") {}
~TfliteSqueezeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_stack_parser.h
View File

@ -29,6 +29,8 @@ class TfliteStackParser : public TfliteNodeParser {
public:
TfliteStackParser() : TfliteNodeParser("Stack") {}
~TfliteStackParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_strided_slice_parser.h
View File

@ -29,6 +29,8 @@ class TfliteStridedSliceParser : public TfliteNodeParser {
public:
TfliteStridedSliceParser() : TfliteNodeParser("StridedSlice") {}
~TfliteStridedSliceParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_tile_parser.h
View File

@ -29,6 +29,8 @@ class TfliteTileParser : public TfliteNodeParser {
public:
TfliteTileParser() : TfliteNodeParser("Tile") {}
~TfliteTileParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_topk_v2_parser.h
View File

@ -29,6 +29,8 @@ class TfliteTopKV2Parser : public TfliteNodeParser {
public:
TfliteTopKV2Parser() : TfliteNodeParser("TopKV2") {}
~TfliteTopKV2Parser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_transpose_parser.h
View File

@ -29,6 +29,8 @@ class TfliteTransposeParser : public TfliteNodeParser {
public:
TfliteTransposeParser() : TfliteNodeParser("Transpose") {}
~TfliteTransposeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_unique_parser.h
View File

@ -29,6 +29,8 @@ class TfliteUniqueParser : public TfliteNodeParser {
public:
TfliteUniqueParser() : TfliteNodeParser("Unique") {}
~TfliteUniqueParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_unstack_parser.h
View File

@ -29,6 +29,8 @@ class TfliteUnstackParser : public TfliteNodeParser {
public:
TfliteUnstackParser() : TfliteNodeParser("Unstack") {}
~TfliteUnstackParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_where_parser.h
View File

@ -29,6 +29,8 @@ class TfliteWhereParser : public TfliteNodeParser {
public:
TfliteWhereParser() : TfliteNodeParser("Where") {}
~TfliteWhereParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_while_parser.h
View File

@ -29,6 +29,8 @@ class TfliteWhileParser : public TfliteNodeParser {
public:
TfliteWhileParser() : TfliteNodeParser("While") {}
~TfliteWhileParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/converter/parser/tflite/tflite_zeros_like_parser.h
View File

@ -29,6 +29,8 @@ class TfliteZerosLikeParser : public TfliteNodeParser {
public:
TfliteZerosLikeParser() : TfliteNodeParser("ZerosLike") {}
~TfliteZerosLikeParser() override = default;
ops::PrimitiveC *Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
const std::unique_ptr<tflite::ModelT> &tflite_model) override;
};

2
mindspore/lite/tools/optimizer/graph/functionalize_cond.h
View File

@ -36,6 +36,8 @@ class FunctionalizeCond {
public:
FunctionalizeCond(FuncGraphPtr fg, CNodePtr merge_node) : fg_(fg), merge_node_(merge_node) {}
~FunctionalizeCond() = default;
STATUS Process();
private:

2
mindspore/lite/tools/optimizer/graph/functionalize_while.h
View File

@ -35,6 +35,8 @@ class FunctionalizeWhile {
FunctionalizeWhile(std::vector<AnfNodePtr> node_cluster, const CNodePtr &loop_cond_node, FuncGraphPtr fg)
: node_cluster_(node_cluster), loop_cond_node_(loop_cond_node), fg_(fg) {}
~FunctionalizeWhile() = default;
// while
STATUS BuildWhileNode();
STATUS IdentifyWhileNodeInput();