fix depthwise

Author: Semyon1104

app/Graph/build.cpp

@@ -82,7 +82,7 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
       it_lab_ai::Tensor tmp_values = tensor;
       it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
       auto conv_layer = it_lab_ai::LayerFactory::createConvLayer(
-          1, pads, 1, tmp_values, tmp_bias, 1, options,true);
+          options, 1, pads, 1, tmp_values, tmp_bias, 1, true);
       layer_ptrs.push_back(conv_layer.get());
       layers.push_back(std::move(conv_layer));
       layerpostop.push_back(false);
@@ -411,7 +411,7 @@ ParseResult parse_json_model(RuntimeOptions options,
         it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
 
         auto conv_layer = it_lab_ai::LayerFactory::createConvLayer(
-            stride, pads, dilations, tmp_tensor, tmp_bias, group, options);
+            options, stride, pads, dilations, tmp_tensor, tmp_bias, group);
         layer = std::move(conv_layer);
       } else if (layer_type.find("Relu") != std::string::npos ||
                  layer_type.find("relu") != std::string::npos) {

app/Graph/build.hpp

@@ -88,9 +88,9 @@ class LayerFactory {
   }
 
   static std::unique_ptr<Layer> createConvLayer(
-      size_t step, size_t pads, size_t dilations, const Tensor& kernel,
-      const Tensor& bias = Tensor(), size_t group = 1,
-      const RuntimeOptions& options, bool useLegacyImpl = false) {
+      const RuntimeOptions& options, size_t step, size_t pads, size_t dilations,
+      const Tensor& kernel, const Tensor& bias = Tensor(), size_t group = 1,
+      bool useLegacyImpl = false) {
     if (options.backend == Backend::kOneDnn) {
       return std::make_unique<ConvLayerOneDnn>(step, pads, dilations, kernel,
                                                bias, group, useLegacyImpl);

include/layers_oneDNN/ConvLayer.hpp

@@ -12,26 +12,19 @@ namespace it_lab_ai {
 class ConvLayerOneDnn : public Layer {
  public:
   ConvLayerOneDnn()
-      : Layer(kConvolution),
-        stride_(1),
-        pads_(0),
-        dilations_(1),
-        group_(1),
-        depthwise_(false) {}
+      : Layer(kConvolution), stride_(1), pads_(0), dilations_(1), group_(1) {}
 
   ConvLayerOneDnn(size_t stride, size_t pads, size_t dilations,
                   const Tensor& kernel, const Tensor& bias = Tensor(),
-                  size_t group = 1, bool use_legacy = false,
-                  bool depthwise = false)
+                  size_t group = 1, bool use_legacy = false)
       : Layer(kConvolution),
         stride_(stride),
         pads_(pads),
         dilations_(dilations),
         kernel_(kernel),
         bias_(bias),
         group_(group),
-        use_legacy_(use_legacy),
-        depthwise_(depthwise) {}
+        use_legacy_(use_legacy) {}
 
   void run(const std::vector<Tensor>& input,
            std::vector<Tensor>& output) override;
@@ -89,7 +82,6 @@ class ConvLayerOneDnn : public Layer {
   Tensor bias_;
   size_t group_;
   bool use_legacy_;
-  bool depthwise_;
 
   std::unique_ptr<dnnl::engine> engine_;
   std::unique_ptr<dnnl::stream> stream_;

src/layers_oneDNN/ConvLayer.cpp

@@ -160,12 +160,8 @@ void ConvLayerOneDnn::validate_depthwise_input(
 }
 
 bool ConvLayerOneDnn::is_depthwise_convolution() const {
-  if (depthwise_) {
-    return true;
-  }
-
   const Shape& kernel_shape = kernel_.get_shape();
-  return (group_ > 1 && kernel_shape[1] == 1);
+  return (group_ == kernel_shape[0]);
 }
 
 void ConvLayerOneDnn::initialize_convolution(const Shape& input_shape,

test/single_layer/test_convlayer_onednn.cpp

@@ -131,7 +131,7 @@ TEST(convlayer_onednn, depthwise_convolution) {
   Tensor input = make_tensor(input_data, Shape({1, 3, 5, 5}));
   Tensor kernel = make_tensor(kernel_data, Shape({3, 1, 3, 3}));
 
-  ConvLayerOneDnn layer(1, 0, 1, kernel, Tensor(), 3, false, true);
+  ConvLayerOneDnn layer(1, 0, 1, kernel, Tensor(), 3, false);
 
   Tensor output;
   std::vector<Tensor> in{input};
@@ -395,7 +395,7 @@ TEST(convlayer_onednn, depthwise_kernel_shape_validation) {
   std::vector<float> kernel_data(3 * 2 * 3 * 3, 1.0f);
   Tensor kernel = make_tensor(kernel_data, Shape({3, 2, 3, 3}));
 
-  ConvLayerOneDnn layer(1, 0, 1, kernel, Tensor(), 3, false, true);
+  ConvLayerOneDnn layer(1, 0, 1, kernel, Tensor(), 3, false);
 
   std::vector<float> input_data(1 * 3 * 5 * 5, 1.0f);
   Tensor input = make_tensor(input_data, Shape({1, 3, 5, 5}));
@@ -406,31 +406,6 @@ TEST(convlayer_onednn, depthwise_kernel_shape_validation) {
   EXPECT_THROW(layer.run(in, out), std::runtime_error);
 }
 
-TEST(convlayer_onednn, unsupported_data_type_validation) {
-  std::vector<float> kernel_data(3 * 3, 1.0f);
-  Tensor kernel = make_tensor(kernel_data, Shape({1, 1, 3, 3}));
-  ConvLayerOneDnn layer(1, 0, 1, kernel);
-
-  std::vector<float> input_data(16, 1.0f);
-  Tensor input = make_tensor(input_data, Shape({1, 1, 4, 4}));
-  Tensor output;
-  std::vector<Tensor> in{input};
-  std::vector<Tensor> out{output};
-
-  EXPECT_NO_THROW(layer.run(in, out));
-  std::vector<int> kernel_data_int(3 * 3, 1);
-  Tensor kernel_int = make_tensor(kernel_data_int, Shape({1, 1, 3, 3}));
-  ConvLayerOneDnn layer_int(1, 0, 1, kernel_int);
-
-  std::vector<int> input_data_int(16, 1);
-  Tensor input_int = make_tensor(input_data_int, Shape({1, 1, 4, 4}));
-  Tensor output_int;
-  std::vector<Tensor> in_int{input_int};
-  std::vector<Tensor> out_int{output_int};
-
-  EXPECT_NO_THROW(layer_int.run(in_int, out_int));
-}
-
 TEST(convlayer_onednn, bias_memory_handling) {
   {
     std::vector<float> kernel_data(2 * 3 * 3 * 3, 1.0f);
@@ -474,7 +449,7 @@ TEST(convlayer_onednn, bias_memory_handling) {
     Tensor kernel = make_tensor(kernel_data, Shape({3, 1, 3, 3}));
     Tensor bias = make_tensor(bias_data, Shape({3}));
 
-    ConvLayerOneDnn layer(1, 0, 1, kernel, bias, 3, false, true);
+    ConvLayerOneDnn layer(1, 0, 1, kernel, bias, 3, false);
 
     std::vector<float> input_data(1 * 3 * 5 * 5, 1.0f);
     Tensor input = make_tensor(input_data, Shape({1, 3, 5, 5}));