add parser

mindspore/lite/schema/model.fbs

@@ -187,7 +187,9 @@ union PrimitiveType {
     DivGrad,
     PowerGrad,
     ActivationGrad,
-    PriorBox
+    PriorBox,
+    SpaceToBatchND,
+    TopKV2
 }
 
 enum QuantType: int {

mindspore/lite/schema/ops.fbs

@@ -677,12 +677,16 @@ table SpaceToBatch {
 }
 
 table SparseToDense {
+    outputShape: [int];
+    sparseValue: [int];
+    defaultValue: [int];
     validateIndices: bool;
 }
 
 table ReverseSequence {
     seqAxis: int;
     batchAxis: int;
+    seqLengths: [int];
 }
 
 table Rank {
@@ -781,6 +785,7 @@ table ScatterND {
 }
 
 table Unique {
+    outType: int;
 }
 
 table Unstack {
@@ -820,6 +825,7 @@ table OptMomentum {
 
 
 table Where{
+    condition: [bool];
 }
 
 table OneHot {
@@ -829,7 +835,7 @@ table OneHot {
 table Lstm{
     bidirection: bool = false;
 }
-
+ 
 table PriorBox {
     min_sizes: [int];
     max_sizes: [int];
@@ -843,3 +849,14 @@ table PriorBox {
     flip: bool = true;
     offset: float;
 }
+
+table SpaceToBatchND {
+    blockShape : [int];
+    paddings : [int];
+}
+
+table TopKV2 {
+    k : [int];
+    sorted : bool = true;
+}
+

mindspore/lite/tools/converter/parser/tflite/tflite_add_parser.cc

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_add_parser.h"
+#include "tools/converter/parser/tflite/tflite_add_parser.h"
 #include <vector>
 #include <memory>
 

mindspore/lite/tools/converter/parser/tflite/tflite_add_parser.h

@@ -19,8 +19,8 @@
 
 #include <memory>
 #include <vector>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser.h"
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h"
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_addn_parser.cc

@@ -0,0 +1,44 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* distributed under the License is distributed on an AS
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <vector>
+#include <memory>
+#include "tools/converter/parser/tflite/tflite_addn_parser.h"
+
+namespace mindspore {
+namespace lite {
+STATUS TfliteAddNParser::Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+                               const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+                               const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+                               const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset,
+                               schema::CNodeT *op,
+                               TensorCache *tensor_cache,
+                               bool quantized_model) {
+  MS_LOG(DEBUG) << "parse TfliteAddNParser";
+  std::unique_ptr<schema::AddNT> attr(new schema::AddNT());
+  attr->N = tflite_tensors.size();
+  if (op != nullptr) {
+    op->primitive = std::make_unique<schema::PrimitiveT>();
+    op->primitive->value.type = schema::PrimitiveType_AddN;
+    op->primitive->value.value = attr.release();
+  }
+  return RET_OK;
+}
+
+TfliteNodeRegister g_tfliteAddNParser("AddN", new TfliteAddNParser());
+}  // namespace lite
+}  // namespace mindspore

mindspore/lite/tools/converter/parser/tflite/tflite_addn_parser.h

@@ -0,0 +1,41 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef LITE_TFLITE_ADDN_PARSER_H
+#define LITE_TFLITE_ADDN_PARSER_H
+
+#include <memory>
+#include <vector>
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
+
+namespace mindspore {
+namespace lite {
+class TfliteAddNParser : public TfliteNodeParser {
+ public:
+  TfliteAddNParser() : TfliteNodeParser("AddN") {}
+
+  STATUS Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+               const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+               const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+               const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset, schema::CNodeT *op,
+               TensorCache *tensor_cache,
+               bool quantized_model) override;
+};
+}  // namespace lite
+}  // namespace mindspore
+
+#endif  // LITE_TFLITE_ADDN_PARSER_H

mindspore/lite/tools/converter/parser/tflite/tflite_argmax_parser.cc

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_argmax_parser.h"
+#include "tools/converter/parser/tflite/tflite_argmax_parser.h"
 #include <memory>
 #include <vector>
 

mindspore/lite/tools/converter/parser/tflite/tflite_argmax_parser.h

@@ -19,8 +19,8 @@
 
 #include <vector>
 #include <memory>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser.h"
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h"
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_argmin_parser.cc

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_argmin_parser.h"
+#include "tools/converter/parser/tflite/tflite_argmin_parser.h"
 #include <memory>
 #include <vector>
 

mindspore/lite/tools/converter/parser/tflite/tflite_argmin_parser.h

@@ -19,8 +19,8 @@
 
 #include <vector>
 #include <memory>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser.h"
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h"
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_batch_to_space_parser.cc

@@ -0,0 +1,51 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* distributed under the License is distributed on an AS
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <vector>
+#include <memory>
+#include "tools/converter/parser/tflite/tflite_batch_to_space_parser.h"
+
+namespace mindspore {
+namespace lite {
+STATUS TfliteBatchToSpaceParser::Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+                                       const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+                                       const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+                                       const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset,
+                                       schema::CNodeT *op,
+                                       TensorCache *tensor_cache, bool quantized_model) {
+  MS_LOG(DEBUG) << "parse TfliteBatchToSpaceParser";
+  std::unique_ptr<schema::BatchToSpaceT> attr(new schema::BatchToSpaceT());
+  if (GetTfliteData(tflite_op->inputs[1], tflite_tensors, tflite_model_buffer, attr->blockShape)) {
+    MS_LOG(ERROR) << "batchToSpace -> blockShape get failed";
+    return RET_ERROR;
+  }
+  if (GetTfliteData(tflite_op->inputs[2], tflite_tensors, tflite_model_buffer, attr->crops)) {
+    MS_LOG(ERROR) << "batchToSpace -> crops get failed";
+    return RET_ERROR;
+  }
+
+  if (op != nullptr) {
+    op->primitive = std::make_unique<schema::PrimitiveT>();
+    op->primitive->value.type = schema::PrimitiveType_BatchToSpace;
+    op->primitive->value.value = attr.release();
+  }
+  return RET_OK;
+}
+
+TfliteNodeRegister g_tfliteBatchToSpaceParser("BatchToSpace", new TfliteBatchToSpaceParser());
+}  // namespace lite
+}  // namespace mindspore

mindspore/lite/tools/converter/parser/tflite/tflite_batch_to_space_parser.h

@@ -0,0 +1,41 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef LITE_TFLITE_BATCH_TO_SPACE_PARSER_H
+#define LITE_TFLITE_BATCH_TO_SPACE_PARSER_H
+
+#include <memory>
+#include <vector>
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
+
+namespace mindspore {
+namespace lite {
+class TfliteBatchToSpaceParser : public TfliteNodeParser {
+ public:
+  TfliteBatchToSpaceParser() : TfliteNodeParser("BatchToSpace") {}
+
+  STATUS Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+               const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+               const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+               const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset, schema::CNodeT *op,
+               TensorCache *tensor_cache,
+               bool quantized_model) override;
+};
+}  // namespace lite
+}  // namespace mindspore
+
+#endif  // LITE_TFLITE_BATCH_TO_SPACE_PARSER_H

mindspore/lite/tools/converter/parser/tflite/tflite_broadcast_to_parser.cc

@@ -0,0 +1,47 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* distributed under the License is distributed on an AS
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <vector>
+#include <memory>
+#include "tools/converter/parser/tflite/tflite_broadcast_to_parser.h"
+
+namespace mindspore {
+namespace lite {
+STATUS TfliteBroadcastToParser::Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+                                      const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+                                      const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+                                      const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset,
+                                      schema::CNodeT *op,
+                                      TensorCache *tensor_cache, bool quantized_model) {
+  MS_LOG(DEBUG) << "parse TfliteBroadcastToParser";
+  std::unique_ptr<schema::BroadcastToT> attr(new schema::BroadcastToT());
+  if (GetTfliteData(tflite_op->inputs[1], tflite_tensors, tflite_model_buffer, attr->dst_shape)) {
+    MS_LOG(ERROR) << "broadCastTo -> dst_shape get failed";
+    return RET_ERROR;
+  }
+
+    if (op != nullptr) {
+      op->primitive = std::make_unique<schema::PrimitiveT>();
+      op->primitive->value.type = schema::PrimitiveType_BroadcastTo;
+      op->primitive->value.value = attr.release();
+    }
+    return RET_OK;
+}
+
+TfliteNodeRegister g_tfliteBroadcastToParser("BroadcastTo", new TfliteBroadcastToParser());
+}  // namespace lite
+}  // namespace mindspore

mindspore/lite/tools/converter/parser/tflite/tflite_broadcast_to_parser.h

@@ -0,0 +1,41 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef LITE_TFLITE_BROADCAST_TO_PARSER_H
+#define LITE_TFLITE_BROADCAST_TO_PARSER_H
+
+#include <memory>
+#include <vector>
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
+
+namespace mindspore {
+namespace lite {
+class TfliteBroadcastToParser : public TfliteNodeParser {
+ public:
+  TfliteBroadcastToParser() : TfliteNodeParser("BroadcastTo") {}
+
+  STATUS Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+               const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+               const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+               const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset, schema::CNodeT *op,
+               TensorCache *tensor_cache,
+               bool quantized_model) override;
+};
+}  // namespace lite
+}  // namespace mindspore
+
+#endif  // LITE_TFLITE_BROADCAST_TO_PARSER_H

mindspore/lite/tools/converter/parser/tflite/tflite_cast_parser.cc

@@ -0,0 +1,51 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* distributed under the License is distributed on an AS
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <vector>
+#include <memory>
+#include "tools/converter/parser/tflite/tflite_cast_parser.h"
+
+namespace mindspore {
+namespace lite {
+STATUS TfliteCastParser::Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+                               const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+                               const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+                               const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset,
+                               schema::CNodeT *op,
+                               TensorCache *tensor_cache, bool quantized_model) {
+  MS_LOG(DEBUG) << "parse TfliteCastParser";
+  std::unique_ptr<schema::CastT> attr(new schema::CastT());
+  const auto &tflite_attr = tflite_op->builtin_options.AsCastOptions();
+  if (tflite_attr == nullptr) {
+    MS_LOG(ERROR) << "get op:" << op->name.c_str() << " attr failed";
+    return RET_NULL_PTR;
+  }
+
+  attr->srcT = tflite_attr->in_data_type;
+  attr->dstT = tflite_attr->out_data_type;
+
+  if (op != nullptr) {
+    op->primitive = std::make_unique<schema::PrimitiveT>();
+    op->primitive->value.type = schema::PrimitiveType_Cast;
+    op->primitive->value.value = attr.release();
+  }
+  return RET_OK;
+}
+
+  TfliteNodeRegister g_tfliteCastParser("Cast", new TfliteCastParser());
+}  // namespace lite
+}  // namespace mindspore

mindspore/lite/tools/converter/parser/tflite/tflite_cast_parser.h

@@ -0,0 +1,41 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef LITE_TFLITE_CAST_PARSER_H
+#define LITE_TFLITE_CAST_PARSER_H
+
+#include <memory>
+#include <vector>
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
+
+namespace mindspore {
+namespace lite {
+class TfliteCastParser : public TfliteNodeParser {
+ public:
+  TfliteCastParser() : TfliteNodeParser("Cast") {}
+
+  STATUS Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+               const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+               const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+               const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset, schema::CNodeT *op,
+               TensorCache *tensor_cache,
+               bool quantized_model) override;
+};
+}  // namespace lite
+}  // namespace mindspore
+
+#endif  // LITE_TFLITE_CAST_PARSER_H

mindspore/lite/tools/converter/parser/tflite/tflite_ceil_parser.cc

@@ -16,7 +16,7 @@
 
 #include <vector>
 #include <memory>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_ceil_parser.h"
+#include "tools/converter/parser/tflite/tflite_ceil_parser.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_ceil_parser.h

@@ -19,8 +19,8 @@
 
 #include <memory>
 #include <vector>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser.h"
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h"
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_concat_parser.cc

@@ -16,7 +16,7 @@
 
 #include <vector>
 #include <memory>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_concat_parser.h"
+#include "tools/converter/parser/tflite/tflite_concat_parser.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_concat_parser.h

@@ -19,8 +19,8 @@
 
 #include <vector>
 #include <memory>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser.h"
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h"
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_conv_parser.cc

@@ -16,7 +16,7 @@
 
 #include <vector>
 #include <memory>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_conv_parser.h"
+#include "tools/converter/parser/tflite/tflite_conv_parser.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_conv_parser.h

@@ -19,8 +19,8 @@
 
 #include <memory>
 #include <vector>
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser.h"
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_node_parser_registry.h"
+#include "tools/converter/parser/tflite/tflite_node_parser.h"
+#include "tools/converter/parser/tflite/tflite_node_parser_registry.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_converter.cc

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_converter.h"
+#include "tools/converter/parser/tflite/tflite_converter.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_converter.h

@@ -19,9 +19,9 @@
 
 #include <string>
 #include <memory>
-#include "mindspore/lite/tools/converter/converter.h"
-#include "mindspore/lite/tools/converter/parser/tflite/tflite_model_parser.h"
-#include "mindspore/lite/tools/converter/graphdef_transform.h"
+#include "tools/converter/converter.h"
+#include "tools/converter/parser/tflite/tflite_model_parser.h"
+#include "tools/converter/graphdef_transform.h"
 
 namespace mindspore {
 namespace lite {

mindspore/lite/tools/converter/parser/tflite/tflite_depth_to_space_parser.cc

@@ -0,0 +1,50 @@
+/**
+* Copyright 2020 Huawei Technologies Co., Ltd
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* distributed under the License is distributed on an AS
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <vector>
+#include <memory>
+#include "tools/converter/parser/tflite/tflite_depth_to_space_parser.h"
+
+namespace mindspore {
+namespace lite {
+STATUS TfliteDepthToSpaceParser::Parse(const std::unique_ptr<tflite::OperatorT> &tflite_op,
+                                       const std::vector<std::unique_ptr<tflite::TensorT>> &tflite_tensors,
+                                       const std::vector<std::unique_ptr<tflite::BufferT>> &tflite_model_buffer,
+                                       const std::vector<std::unique_ptr<tflite::OperatorCodeT>> &tflite_opset,
+                                       schema::CNodeT *op,
+                                       TensorCache *tensor_cache, bool quantized_model) {
+  MS_LOG(DEBUG) << "parse TfliteDepthToSpaceParser";
+  std::unique_ptr<schema::DepthToSpaceT> attr(new schema::DepthToSpaceT());
+  const auto &tflite_attr = tflite_op->builtin_options.AsDepthToSpaceOptions();
+  if (tflite_attr == nullptr) {
+    MS_LOG(ERROR) << "get op: %s attr failed", op->name.c_str();
+    return RET_NULL_PTR;
+  }
+  attr->blockSize = tflite_attr->block_size;
+  attr->format = schema::Format_NHWC;
+
+  if (op != nullptr) {
+    op->primitive = std::make_unique<schema::PrimitiveT>();
+    op->primitive->value.type = schema::PrimitiveType_DepthToSpace;
+    op->primitive->value.value = attr.release();
+  }
+  return RET_OK;
+}
+
+TfliteNodeRegister g_tfliteDepthToSpaceParser("DepthToSpace", new TfliteDepthToSpaceParser());
+}  // namespace lite
+}  // namespace mindspore