Add support for prelu

Author: daquexian

Diff for: common/flatbuffers_helper.h

@@ -150,6 +150,8 @@ inline std::string layer_type_to_str(flatbnn::LayerType type) {
             return "split";
         case flatbnn::LayerType::Shuffle:
             return "shuffle";
+        case flatbnn::LayerType::PRelu:
+            return "prelu";
         default:
             BNN_ASSERT(false, "Missing type in this function");
     }

Diff for: dabnn/layers/PRelu.h

@@ -11,8 +11,8 @@ class PRelu : public Layer {
     MatCP data_mat;
     MatCP slope_mat;
 
-    PRelu(NetCP net, const std::string &name, css data)
-        : Layer(net, name, "PRelu"), data_mat(mat(data)) {}
+    PRelu(NetCP net, const std::string &name, css data, css slope)
+        : Layer(net, name, "PRelu"), data_mat(mat(data)), slope_mat(mat(slope)) {}
     virtual void forward_impl() const;
 };
 }  // namespace bnn

Diff for: dabnn/net.cpp

@@ -22,6 +22,7 @@
 #include <dabnn/layers/Relu.h>
 #include <dabnn/layers/Shuffle.h>
 #include <dabnn/layers/Split.h>
+#include <dabnn/layers/PRelu.h>
 
 using std::string;
 using std::vector;
@@ -253,6 +254,12 @@ void Net::prepare() {
                     std::make_shared<Shuffle>(get_weak(), name, input));
                 break;
             }
+            case flatbnn::LayerType::PRelu: {
+                ADD_INPLACE_LAYER(prelu, Eltwise, input, slope, output);
+                layers.push_back(
+                    std::make_shared<PRelu>(get_weak(), name, input, slope));
+                break;
+            }
             default: {
                 throw std::runtime_error("Not supported op " +
                                          layer_type_to_str(layer->type()));

Diff for: tools/onnx2bnn/OnnxConverter.cpp

@@ -356,7 +356,7 @@ std::vector<std::string> OnnxConverter::Convert(
             layers_.push_back(layer);
             VLOG(5) << "Converting Pool completed";
         } else if (op == "PRelu") {
-            VLOG(5) << "Start converting Relu";
+            VLOG(5) << "Start converting PRelu";
             auto input_name = m(node.input(0));
             auto slope_name = m(node.input(1));
             const auto onnx_slope_tensor = onnx_float_tensors_.at(slope_name);
@@ -366,7 +366,7 @@ std::vector<std::string> OnnxConverter::Convert(
             BNN_ASSERT(
                 (slope_shape.size() == 3 && slope_shape[1] == 1 &&
                  slope_shape[2] == 1) ||
-                    onnx_slope_tensor.data == {1},
+                    onnx_slope_tensor.data == std::vector<float>{1},
                 "PRelu only support scalr slope or per-channel slope for now");
             const Shape flat_slope_shape{slope_shape[0]};
             auto flat_slope_tensor = flatbnn::CreateTensorDirect(
@@ -382,7 +382,7 @@ std::vector<std::string> OnnxConverter::Convert(
                 flatbnn::CreateLayer(builder_, flatbnn::LayerType::PRelu, 0, 0,
                                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, param);
             layers_.push_back(layer);
-            VLOG(5) << "Converting Relu completed";
+            VLOG(5) << "Converting PRelu completed";
         } else if (op == "Relu") {
             VLOG(5) << "Start converting Relu";
             auto input_name = m(node.input(0));