Implement mechanism for subgraph replacement

app/Graph/CMakeLists.txt

@@ -22,6 +22,10 @@ target_link_libraries(Graph_Build BuildGraph)
 add_executable(ACC acc_check.cpp)
 target_link_libraries(ACC BuildGraph)
 
+add_executable(onnx_subs onnx_subs.cpp)
+target_link_libraries(onnx_subs BuildGraph)
+target_link_libraries(onnx_subs graphT_lib)
+
 if (WIN32)
     add_custom_command(TARGET Graph_Build POST_BUILD
         COMMAND ${CMAKE_COMMAND} -E copy_directory

app/Graph/build.cpp

@@ -19,20 +19,6 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
     for (size_t i = 0; i < input.get_shape().dims(); i++) {
       std::cout << input.get_shape()[i] << ' ';
     }
-    std::cout << std::endl;
-    if (input.get_shape().dims() == 4) {
-      for (size_t n = 0; n < input.get_shape()[0]; n++) {
-        for (size_t h = 0; h < input.get_shape()[2]; h++) {
-          for (size_t w = 0; w < input.get_shape()[3]; w++) {
-            for (size_t c = 0; c < input.get_shape()[1]; c++) {
-              std::cout << input.get<float>({n, c, h, w}) << ' ';
-            }
-          }
-          std::cerr << std::endl;
-        }
-      }
-      std::cout << std::endl << std::endl;
-    }
   }
   std::vector<std::unique_ptr<it_lab_ai::Layer>> layers;
   std::vector<Layer*> layer_ptrs;
@@ -79,10 +65,13 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
         std::cout << std::endl;
       }
 
-      it_lab_ai::Tensor tmp_values = tensor;
-      it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
+      std::shared_ptr<it_lab_ai::Tensor> tmp_values =
+          std::make_shared<it_lab_ai::Tensor>(tensor);
+      std::shared_ptr<it_lab_ai::Tensor> tmp_bias =
+          std::make_shared<it_lab_ai::Tensor>(
+              it_lab_ai::make_tensor(tensor.get_bias()));
       auto conv_layer = std::make_unique<it_lab_ai::ConvolutionalLayer>(
-          1, pads, 1, tmp_values, tmp_bias, kDefault, 1, true);
+          1, pads, 1, *tmp_values, *tmp_bias, kDefault, 1, true);
       layer_ptrs.push_back(conv_layer.get());
       layers.push_back(std::move(conv_layer));
       layerpostop.push_back(false);
@@ -97,8 +86,13 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
         std::cout << "Element wise (relu) added to layers" << std::endl;
     }
     if (layer_type.find("Dense") != std::string::npos) {
-      it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
-      auto fc_layer = std::make_unique<it_lab_ai::FCLayer>(tensor, tmp_bias);
+      std::shared_ptr<it_lab_ai::Tensor> tmp_tensor =
+          std::make_shared<it_lab_ai::Tensor>(tensor);
+      std::shared_ptr<it_lab_ai::Tensor> tmp_bias =
+          std::make_shared<it_lab_ai::Tensor>(
+              it_lab_ai::make_tensor(tensor.get_bias()));
+      auto fc_layer =
+          std::make_unique<it_lab_ai::FCLayer>(*tmp_tensor, *tmp_bias);
       layer_ptrs.push_back(fc_layer.get());
       layers.push_back(std::move(fc_layer));
       layerpostop.push_back(false);
@@ -171,11 +165,6 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
   }
 
   graph.setOutput(layer_ptrs.back(), output);
-
-  graph.addOwnedLayer(std::move(a1));
-  for (auto& layer : layers) {
-    graph.addOwnedLayer(std::move(layer));
-  }
 }
 
 std::string get_base_layer_name(const std::string& tensor_name) {
@@ -323,10 +312,6 @@ void build_graph(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
     auto* output_layer = layers.back().get();
     graph.setOutput(output_layer, output);
   }
-
-  for (auto& layer : layers) {
-    graph.addOwnedLayer(std::move(layer));
-  }
 }
 
 ParseResult parse_json_model(const std::string& json_path, bool comments) {
@@ -436,11 +421,14 @@ ParseResult parse_json_model(const std::string& json_path, bool comments) {
           }
         }
 
-        it_lab_ai::Tensor tmp_tensor = tensor;
-        it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
+        std::shared_ptr<it_lab_ai::Tensor> tmp_tensor =
+            std::make_shared<it_lab_ai::Tensor>(tensor);
+        std::shared_ptr<it_lab_ai::Tensor> tmp_bias =
+            std::make_shared<it_lab_ai::Tensor>(
+                it_lab_ai::make_tensor(tensor.get_bias()));
 
         auto conv_layer = std::make_unique<it_lab_ai::ConvolutionalLayer>(
-            stride, pads, dilations, tmp_tensor, tmp_bias, kDefault, group);
+            stride, pads, dilations, *tmp_tensor, *tmp_bias, kDefault, group);
         layer = std::move(conv_layer);
       } else if (layer_type.find("Relu") != std::string::npos ||
                  layer_type.find("relu") != std::string::npos) {
@@ -452,19 +440,23 @@ ParseResult parse_json_model(const std::string& json_path, bool comments) {
         it_lab_ai::Tensor tensor = it_lab_ai::create_tensor_from_json(
             layer_data, it_lab_ai::Type::kFloat);
 
-        it_lab_ai::Tensor tmp_tensor = it_lab_ai::Tensor(
-            it_lab_ai::Shape({tensor.get_shape()[1], tensor.get_shape()[0]}),
-            it_lab_ai::Type::kFloat);
+        std::shared_ptr<it_lab_ai::Tensor> tmp_tensor =
+            std::make_shared<it_lab_ai::Tensor>(
+                it_lab_ai::Shape(
+                    {tensor.get_shape()[1], tensor.get_shape()[0]}),
+                it_lab_ai::Type::kFloat);
 
         for (size_t h = 0; h < tensor.get_shape()[0]; h++) {
           for (size_t w = 0; w < tensor.get_shape()[1]; w++) {
-            tmp_tensor.set<float>({w, h}, tensor.get<float>({h, w}));
+            tmp_tensor->set<float>({w, h}, tensor.get<float>({h, w}));
           }
         }
 
-        it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
+        std::shared_ptr<it_lab_ai::Tensor> tmp_bias =
+            std::make_shared<it_lab_ai::Tensor>(
+                it_lab_ai::make_tensor(tensor.get_bias()));
         auto fc_layer =
-            std::make_unique<it_lab_ai::FCLayer>(tmp_tensor, tmp_bias);
+            std::make_unique<it_lab_ai::FCLayer>(*tmp_tensor, *tmp_bias);
         layer = std::move(fc_layer);
       } else if (layer_type.find("Dropout") != std::string::npos) {
         auto dropout_layer = std::make_unique<it_lab_ai::DropOutLayer>(0.0);
@@ -710,8 +702,11 @@ ParseResult parse_json_model(const std::string& json_path, bool comments) {
           trans_b = layer_data["transB"].get<int>() != 0;
         }
 
-        it_lab_ai::Tensor tmp_tensor = tensor;
-        it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
+        std::shared_ptr<it_lab_ai::Tensor> tmp_tensor =
+            std::make_shared<it_lab_ai::Tensor>(tensor);
+        std::shared_ptr<it_lab_ai::Tensor> tmp_bias =
+            std::make_shared<it_lab_ai::Tensor>(
+                it_lab_ai::make_tensor(tensor.get_bias()));
         if (trans_b) {
           it_lab_ai::Shape transposed_shape(
               {tensor.get_shape()[1], tensor.get_shape()[0]});
@@ -725,7 +720,7 @@ ParseResult parse_json_model(const std::string& json_path, bool comments) {
             }
           }
 
-          tmp_tensor = transposed_tensor;
+          *tmp_tensor = transposed_tensor;
 
           if (comments) {
             std::cout << "Weights transposed from [" << tensor.get_shape()[0]
@@ -736,23 +731,23 @@ ParseResult parse_json_model(const std::string& json_path, bool comments) {
         }
 
         if (alpha != 1.0F) {
-          auto weights_data = *tmp_tensor.as<float>();
+          auto weights_data = *tmp_tensor->as<float>();
           for (auto& val : weights_data) {
             val *= alpha;
           }
-          tmp_tensor = make_tensor(weights_data, tmp_tensor.get_shape());
+          *tmp_tensor = make_tensor(weights_data, tmp_tensor->get_shape());
         }
 
         if (beta != 1.0F) {
-          auto bias_data = *tmp_bias.as<float>();
+          auto bias_data = *tmp_bias->as<float>();
           for (auto& val : bias_data) {
             val *= beta;
           }
-          tmp_bias = make_tensor(bias_data, tmp_bias.get_shape());
+          *tmp_bias = make_tensor(bias_data, tmp_bias->get_shape());
         }
 
         auto fc_layer =
-            std::make_unique<it_lab_ai::FCLayer>(tmp_tensor, tmp_bias);
+            std::make_unique<it_lab_ai::FCLayer>(*tmp_tensor, *tmp_bias);
         layer = std::move(fc_layer);
       } else if (layer_type == "Transpose" ||
                  layer_type.find("transpose") != std::string::npos) {

app/Graph/onnx_subs.cpp

@@ -0,0 +1,78 @@
+#include <algorithm>
+#include <filesystem>
+#include <iomanip>
+#include <numeric>
+#include <sstream>
+#include <unordered_map>
+
+#include "graph_transformations/graph_transformations.hpp"
+#include "perf/benchmarking.hpp"
+#include "build.cpp"
+#include "build.hpp"
+
+using namespace it_lab_ai;
+
+int main() {
+  Tensor aaaa = make_tensor(std::vector<int>({0}));
+  Graph graph1;
+  build_graph(graph1, aaaa, aaaa, MODEL_PATH_DENSENET_ONNX, false);
+
+  Graph subgraph;
+  Tensor scale = make_tensor(std::vector<float>({1.0}));
+  std::unique_ptr<Layer> layer_0 =
+      std::make_unique<BatchNormalizationLayer>(scale, scale, scale, scale);
+  std::unique_ptr<Layer> layer_1 = std::make_unique<EWLayer>("relu");
+  std::unique_ptr<Layer> layer_2 = std::make_unique<ConvolutionalLayer>();
+  std::unique_ptr<Layer> layer_3 = std::make_unique<EWLayer>("relu");
+  std::unique_ptr<Layer> layer_4 = std::make_unique<ConvolutionalLayer>();
+
+  Layer* layer_0_ptr = layer_0.get();
+  Layer* layer_1_ptr = layer_1.get();
+  Layer* layer_2_ptr = layer_2.get();
+  Layer* layer_3_ptr = layer_3.get();
+  Layer* layer_4_ptr = layer_4.get();
+
+  subgraph.setInput(layer_0_ptr, aaaa);
+  subgraph.makeConnection(layer_0_ptr, layer_1_ptr);
+  subgraph.makeConnection(layer_1_ptr, layer_2_ptr);
+  subgraph.makeConnection(layer_2_ptr, layer_3_ptr);
+  subgraph.makeConnection(layer_3_ptr, layer_4_ptr);
+
+  Graph subgraph2;
+  std::unique_ptr<Layer> layer_5 = std::make_unique<ConcatLayer>();
+  std::unique_ptr<Layer> layer_6 =
+      std::make_unique<PoolingLayer>(Shape({1, 1, 1}), "max");
+  std::unique_ptr<Layer> layer_7 = std::make_unique<ConvolutionalLayer>();
+
+  Layer* layer_5_ptr = layer_5.get();
+  Layer* layer_6_ptr = layer_6.get();
+  Layer* layer_7_ptr = layer_7.get();
+
+  subgraph2.setInput(layer_6_ptr, aaaa);
+  subgraph2.makeConnection(layer_6_ptr, layer_5_ptr);
+  subgraph2.addSingleLayer(layer_7_ptr);
+  subgraph2.makeConnection(layer_7_ptr, layer_5_ptr);
+
+  std::vector<std::vector<int>> vec = find_subgraphs(graph1, subgraph);
+  std::vector<std::vector<int>> vec2 = find_subgraphs(graph1, subgraph2);
+  auto time = elapsed_time_avg<double, std::milli>(10, find_subgraphs, graph1,
+                                                   subgraph);
+  auto time2 = elapsed_time_avg<double, std::milli>(10, find_subgraphs, graph1,
+                                                    subgraph2);
+  for (int i = 0; i < vec.size(); i++) {
+    for (int j = 0; j < vec[i].size(); j++) {
+      std::cerr << vec[i][j] << ' ';
+    }
+    std::cerr << '\n';
+  }
+  std::cerr << "Time for path5:" << time << std::endl;
+
+  for (int i = 0; i < vec2.size(); i++) {
+    for (int j = 0; j < vec2[i].size(); j++) {
+      std::cerr << vec2[i][j] << ' ';
+    }
+    std::cerr << '\n';
+  }
+  std::cerr << "Time for concat:" << time2 << std::endl;
+  return 0;
+}