enable shuffle channel fuse (#1834)

test=develop

lite/api/paddle_use_passes.h

@@ -29,6 +29,7 @@ USE_MIR_PASS(graph_visualze);
 
 USE_MIR_PASS(lite_conv_bn_fuse_pass);
 USE_MIR_PASS(lite_fc_fuse_pass);
+USE_MIR_PASS(lite_shuffle_channel_fuse_pass);
 USE_MIR_PASS(identity_scale_eliminate_pass);
 USE_MIR_PASS(lite_conv_elementwise_fuse_pass);
 USE_MIR_PASS(lite_conv_activation_fuse_pass);

lite/core/mir/CMakeLists.txt

@@ -11,6 +11,7 @@ add_subdirectory(subgraph)
 lite_cc_library(mir_passes
   SRCS
       fusion/fc_fuse_pass.cc
+      fusion/shuffle_channel_fuse_pass.cc
       fusion/conv_elementwise_fuse_pass.cc
       fusion/conv_activation_fuse_pass.cc
       fusion/conv_bn_fuse_pass.cc

lite/core/mir/fusion/CMakeLists.txt

 lite_cc_library(fuse_fc
         SRCS fc_fuser.cc
         DEPS pattern_matcher_high_api)
+lite_cc_library(fuse_shuffle_channel
+        SRCS shuffle_channel_fuser.cc
+        DEPS pattern_matcher_high_api)
 lite_cc_library(fuse_conv_elementwise
         SRCS conv_elementwise_fuser.cc
         DEPS pattern_matcher_high_api)
@@ -19,6 +22,7 @@ lite_cc_library(fuse_quant_dequant
 
 set(mir_fusers
     fuse_fc
+    fuse_shuffle_channel
     fuse_conv_elementwise
     fuse_conv_activation
     fuse_conv_bn

lite/core/mir/fusion/shuffle_channel_fuse_pass.cc

+// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+//
+// 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.
+
+#include "lite/core/mir/fusion/shuffle_channel_fuse_pass.h"
+#include <memory>
+#include <vector>
+#include "lite/core/mir/fusion/shuffle_channel_fuser.h"
+#include "lite/core/mir/pass_registry.h"
+
+namespace paddle {
+namespace lite {
+namespace mir {
+
+void ShuffleChannelFusePass::Apply(const std::unique_ptr<SSAGraph>& graph) {
+  fusion::ShuffleChannelFuser fuser("reshape", "transpose");
+  fuser(graph.get());
+
+  fusion::ShuffleChannelFuser fuser2("reshape2", "transpose2");
+  fuser2(graph.get());
+}
+
+}  // namespace mir
+}  // namespace lite
+}  // namespace paddle
+
+REGISTER_MIR_PASS(lite_shuffle_channel_fuse_pass,
+                  paddle::lite::mir::ShuffleChannelFusePass);

lite/core/mir/fusion/shuffle_channel_fuse_pass.h

+// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+//
+// 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.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include "lite/core/mir/pass.h"
+
+namespace paddle {
+namespace lite {
+namespace mir {
+
+class ShuffleChannelFusePass : public ProgramPass {
+ public:
+  void Apply(const std::unique_ptr<SSAGraph>& graph) override;
+};
+
+}  // namespace mir
+}  // namespace lite
+}  // namespace paddle

lite/core/mir/fusion/shuffle_channel_fuser.cc

+// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+//
+// 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.
+
+#include "lite/core/mir/fusion/shuffle_channel_fuser.h"
+#include <memory>
+#include <vector>
+
+namespace paddle {
+namespace lite {
+namespace mir {
+namespace fusion {
+
+void ShuffleChannelFuser::BuildPattern() {
+  // create nodes.
+  auto* x1 = VarNode("x1")->assert_is_op_input(reshape_type_, "X");
+  auto* y1 = VarNode("y1")->assert_is_op_output(reshape_type_, "Out");
+  auto* y2 = VarNode("y2")->assert_is_op_output(transpose_type_, "Out");
+  auto* out = VarNode("out")->assert_is_op_output(reshape_type_, "Out");
+
+  auto* xshape1 =
+      VarNode("xshape1")->assert_is_op_output(reshape_type_, "XShape");
+  auto* xshape2 =
+      VarNode("xshape2")->assert_is_op_output(transpose_type_, "XShape");
+  auto* xshape3 =
+      VarNode("xshape3")->assert_is_op_output(reshape_type_, "XShape");
+
+  auto* reshape1 = OpNode("reshape1", reshape_type_)
+                       ->assert_op_attr_satisfied<std::vector<int>>(
+                           "shape", [](const std::vector<int>& attr) {
+                             return attr.size() >= 5 && attr[1] > 0;
+                           });
+  auto* transpose =
+      OpNode("transpose_op", transpose_type_)
+          ->assert_op_attr_satisfied<std::vector<int>>(
+              "axis", [](const std::vector<int>& attr) {
+                return attr.size() >= 5 && attr[1] == 2 && attr[2] == 1;
+              });
+  auto* reshape2 = OpNode("reshape2", reshape_type_)
+                       ->assert_op_attr_satisfied<std::vector<int>>(
+                           "shape", [](const std::vector<int>& attr) {
+                             return attr.size() >= 4;
+                           });
+
+  // create topology.
+  *x1 >> *reshape1 >> *y1 >> *transpose >> *y2 >> *reshape2 >> *out;
+  *reshape1 >> *xshape1;
+  *transpose >> *xshape2;
+  *reshape2 >> *xshape3;
+
+  // Some op specialities.
+  y1->AsIntermediate();
+  y2->AsIntermediate();
+  xshape1->AsIntermediate();
+  xshape2->AsIntermediate();
+  xshape3->AsIntermediate();
+  reshape1->AsIntermediate();
+  transpose->AsIntermediate();
+  reshape2->AsIntermediate();
+}
+
+void ShuffleChannelFuser::InsertNewNode(SSAGraph* graph,
+                                        const key2nodes_t& matched) {
+  auto op_desc = GenOpDesc(matched);
+  auto shuffle_channel_op = LiteOpRegistry::Global().Create("shuffle_channel");
+  auto transpose = matched.at("transpose_op")->stmt()->op();
+  auto* scope = transpose->scope();
+  auto& valid_places = transpose->valid_places();
+  shuffle_channel_op->Attach(op_desc, scope);
+
+  auto* new_op_node =
+      graph->GraphCreateInstructNode(shuffle_channel_op, valid_places);
+
+  IR_NODE_LINK_TO(matched.at("x1"), new_op_node);
+  IR_NODE_LINK_TO(new_op_node, matched.at("out"));
+}
+
+cpp::OpDesc ShuffleChannelFuser::GenOpDesc(const key2nodes_t& matched) {
+  cpp::OpDesc op_desc;
+  op_desc.SetType("shuffle_channel");
+  op_desc.SetInput("X", {matched.at("x1")->arg()->name});
+  op_desc.SetOutput("Out", {matched.at("out")->arg()->name});
+  op_desc.SetAttr("group",
+                  matched.at("reshape1")
+                      ->stmt()
+                      ->op_info()
+                      ->GetAttr<std::vector<int>>("shape")[1]);
+  return op_desc;
+}
+
+}  // namespace fusion
+}  // namespace mir
+}  // namespace lite
+}  // namespace paddle

lite/core/mir/fusion/shuffle_channel_fuser.h

+// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
+//
+// 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.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include "lite/core/mir/pattern_matcher_high_api.h"
+
+namespace paddle {
+namespace lite {
+namespace mir {
+namespace fusion {
+
+class ShuffleChannelFuser : public FuseBase {
+ public:
+  explicit ShuffleChannelFuser(const std::string& reshape_type,
+                               const std::string& transpose_type)
+      : reshape_type_(reshape_type), transpose_type_(transpose_type) {}
+
+  void BuildPattern() override;
+  void InsertNewNode(SSAGraph* graph, const key2nodes_t& matched) override;
+
+ private:
+  cpp::OpDesc GenOpDesc(const key2nodes_t& matched) override;
+  std::string reshape_type_;
+  std::string transpose_type_;
+};
+
+}  // namespace fusion
+}  // namespace mir
+}  // namespace lite
+}  // namespace paddle

lite/core/mir/pattern_matcher.h

@@ -141,18 +141,26 @@ struct PMNode {
                                   int nth);
 
   template <typename T>
-  PMNode* assert_op_attr(const std::string& attr_name, const T& attr) {
+  PMNode* assert_op_attr_satisfied(
+      const std::string& attr_name,
+      const std::function<bool(const T&)>& condition) {
     asserts_.push_back([=](const Node* x) {
       if (x && x->IsStmt()) {
         auto* op_info = x->stmt()->op_info();
         return op_info->HasAttr(attr_name) &&
-               op_info->GetAttr<T>(attr_name) == attr;
+               condition(op_info->GetAttr<T>(attr_name));
       }
       return false;
     });
     return this;
   }
 
+  template <typename T>
+  PMNode* assert_op_attr(const std::string& attr_name, const T& attr) {
+    return assert_op_attr_satisfied<T>(
+        attr_name, [&](const T& src) { return src == attr; });
+  }
+
  private:
   PMNode(PMPattern* pattern,
          const std::string& name = "",

lite/core/optimizer.h

@@ -64,6 +64,7 @@ class Optimizer {
            "lite_conv_elementwise_fuse_pass",  //
            "lite_conv_activation_fuse_pass",   //
            "lite_fc_fuse_pass",                //
+           "lite_shuffle_channel_fuse_pass",   //
            "identity_scale_eliminate_pass",    //
 #ifdef LITE_WITH_LIGHT_WEIGHT_FRAMEWORK
            "lite_elementwise_add_activation_fuse_pass",  //