Merge branch 'main' into Semyon1104/Acc_Parametrized

Author: Semyon1104

.clang-format

@@ -1,2 +1,17 @@
 Language: Cpp
+Standard: c++20
 BasedOnStyle: Google
+UseTab: Never
+AllowShortFunctionsOnASingleLine: Empty
+IndentPPDirectives: AfterHash
+SortIncludes: true
+FixNamespaceComments: true
+InsertBraces: true
+QualifierAlignment: Left
+PointerAlignment: Right
+ReferenceAlignment: Right
+SortUsingDeclarations: LexicographicNumeric
+InsertNewlineAtEOF: true
+LambdaBodyIndentation: OuterScope
+MaxEmptyLinesToKeep: 1
+LineEnding: LF

.clang-tidy

@@ -1,10 +1,23 @@
 Checks: >
   bugprone-*,
+  google-*,
+  cppcoreguidelines-*,
   modernize-*,
   misc-*,
   performance-*,
   portability-*,
   readability-*,
+  -google-build-using-namespace,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-prefer-member-initializer,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-pro-type-const-cast,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -cppcoreguidelines-pro-type-member-init,
+  -cppcoreguidelines-special-member-functions,
   -google-readability-braces-around-statements,
   -google-readability-namespace-comments,
   -google-runtime-references,

app/Converters/reader_weights_sample.cpp

@@ -25,4 +25,4 @@ int main() {
   }
 
   return 0;
-}
+}

app/Converters/reader_weights_sample_onnx.cpp

@@ -74,4 +74,4 @@ int main() {
   }
 
   return 0;
-}
+}

app/Graph/CMakeLists.txt

@@ -11,6 +11,7 @@ target_link_libraries(BuildGraph PUBLIC ${OpenCV_LIBS})
 target_link_libraries(BuildGraph PUBLIC reader_lib)
 target_link_libraries(BuildGraph PUBLIC TBB_unified)
 target_link_libraries(BuildGraph PUBLIC layers_lib)
+target_link_libraries(BuildGraph PUBLIC layers_fused_lib)
 target_link_libraries(BuildGraph PUBLIC layers_oneDNN_lib)
 target_link_libraries(BuildGraph PUBLIC gtest_main)
 
@@ -25,6 +26,7 @@ target_link_libraries(ACC BuildGraph)
 add_executable(onnx_subgraphs onnx_subgraphs.cpp)
 target_link_libraries(onnx_subgraphs BuildGraph)
 target_link_libraries(onnx_subgraphs OpenMP::OpenMP_CXX)
+target_link_libraries(onnx_subgraphs ${OpenCV_LIBS})
 target_link_libraries(onnx_subgraphs graphT_lib)
 
 file(DOWNLOAD

app/Graph/acc_check.cpp

@@ -120,7 +120,9 @@ int main(int argc, char* argv[]) {
         for (int i = 0; i < 28; ++i) {
           for (int j = 0; j < 28; ++j) {
             size_t a = ind;
-            for (size_t n = 0; n < name; n++) a += counts[n] + 1;
+            for (size_t n = 0; n < name; n++) {
+              a += counts[n] + 1;
+            }
             res[(a) * 28 * 28 + i * 28 + j] = channels[0].at<uchar>(j, i);
           }
         }
@@ -147,8 +149,12 @@ int main(int argc, char* argv[]) {
     for (size_t name = 0; name < 10; name++) {
       for (size_t ind = 0; ind < counts[name] + 1; ind++) {
         size_t a = ind;
-        for (size_t n = 0; n < name; n++) a += counts[n] + 1;
-        if (name == indices[a]) stat++;
+        for (size_t n = 0; n < name; n++) {
+          a += counts[n] + 1;
+        }
+        if (name == indices[a]) {
+          stat++;
+        }
       }
     }
     double percentage =
@@ -219,7 +225,9 @@ int main(int argc, char* argv[]) {
     folder_oss << std::setw(5) << std::setfill('0') << class_id;
     std::string class_folder_path = dataset_path + "/" + folder_oss.str();
 
-    if (!fs::exists(class_folder_path)) continue;
+    if (!fs::exists(class_folder_path)) {
+      continue;
+    }
 
     std::vector<std::string> class_images;
     for (const auto& entry : fs::directory_iterator(class_folder_path)) {
@@ -433,4 +441,4 @@ int main(int argc, char* argv[]) {
             << final_accuracy_top5 << "%" << '\n';
 
   return 0;
-}
+}

app/Graph/build.cpp

@@ -13,7 +13,7 @@ std::unordered_map<std::string, std::string> model_paths = {
 
 void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
                         it_lab_ai::Tensor& output, RuntimeOptions options,
-                        bool comments) {
+                        bool comments, bool enable_postops) {
   if (comments) {
     for (size_t i = 0; i < input.get_shape().dims(); i++) {
       std::cout << input.get_shape()[i] << ' ';
@@ -25,7 +25,9 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
   std::string json_file = MODEL_PATH_H5;
   it_lab_ai::json model_data = it_lab_ai::read_json(json_file);
 
-  if (comments) std::cout << "Loaded model data from JSON." << '\n';
+  if (comments) {
+    std::cout << "Loaded model data from JSON." << '\n';
+  }
 
   for (const auto& layer_data : model_data) {
     std::string layer_type = layer_data["type"];
@@ -70,12 +72,14 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
           options, 1, pads, 1, tmp_values, tmp_bias, 1, true);
       layers.push_back(conv_layer);
       layerpostop.push_back(false);
-      if (comments) std::cout << "ConvLayer added to layers." << '\n';
+      if (comments) {
+        std::cout << "ConvLayer added to layers." << '\n';
+      }
     }
     if (layer_type.find("relu") != std::string::npos) {
       auto ew_layer = LayerFactory::createEwLayer("relu", options);
       layers.push_back(ew_layer);
-      layerpostop.push_back(true);
+      layerpostop.push_back(enable_postops);
       if (comments) {
         std::cout << "Element wise (relu) added to layers" << '\n';
       }
@@ -85,7 +89,9 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
       auto fc_layer = std::make_shared<it_lab_ai::FCLayer>(tensor, tmp_bias);
       layers.push_back(fc_layer);
       layerpostop.push_back(false);
-      if (comments) std::cout << "DenseLayer added to layers." << '\n';
+      if (comments) {
+        std::cout << "DenseLayer added to layers." << '\n';
+      }
     }
 
     if (layer_type.find("Pool") != std::string::npos) {
@@ -105,15 +111,19 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
 
       layers.push_back(pool_layer);
       layerpostop.push_back(false);
-      if (comments) std::cout << "PoolingLayer added to layers." << '\n';
+      if (comments) {
+        std::cout << "PoolingLayer added to layers." << '\n';
+      }
     }
 
     if (layer_type.find("Flatten") != std::string::npos) {
       auto flatten_layer = std::make_shared<it_lab_ai::FlattenLayer>(
           std::vector<size_t>({0, 3, 2, 1}));
       layers.push_back(flatten_layer);
       layerpostop.push_back(false);
-      if (comments) std::cout << "FlattenLayer added to layers." << '\n';
+      if (comments) {
+        std::cout << "FlattenLayer added to layers." << '\n';
+      }
     }
 
     if (layer_type.find("Dropout") != std::string::npos) {
@@ -128,26 +138,34 @@ void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
       }
     }
   }
-  if (comments) std::cout << "number of layers - " << layers.size() + 1 << '\n';
+  if (comments) {
+    std::cout << "number of layers - " << layers.size() + 1 << '\n';
+  }
   auto a1 = std::make_shared<it_lab_ai::InputLayer>(it_lab_ai::kNchw,
                                                     it_lab_ai::kNchw);
 
-  if (comments) std::cout << "InputLayer created." << '\n';
+  if (comments) {
+    std::cout << "InputLayer created." << '\n';
+  }
 
   graph.setInput(a1, input);
-  if (comments) std::cout << "Input set in graph." << '\n';
+  if (comments) {
+    std::cout << "Input set in graph." << '\n';
+  }
 
   graph.makeConnection(a1, layers[0]);
-  if (comments)
+  if (comments) {
     std::cout << "Connection made between InputLayer and first layer." << '\n';
+  }
 
   for (size_t i = 0; i < layers.size() - 1; ++i) {
     if (layerpostop[i]) {
       layers[i - 1]->postops.layers.push_back(layers[i]);
       layers[i - 1]->postops.count++;
       graph.makeConnection(layers[i - 1], layers[i + 1]);
-    } else if (!layerpostop[i + 1])
+    } else if (!layerpostop[i + 1]) {
       graph.makeConnection(layers[i], layers[i + 1]);
+    }
   }
 
   graph.setOutput(layers.back(), output);
@@ -197,13 +215,12 @@ void build_graph(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
   try {
     std::sort(connection_list.begin(), connection_list.end(),
               [&](const auto& a, const auto& b) {
-                if (!name_to_layer.contains(a.first) ||
-                    !name_to_layer.contains(b.first)) {
-                  return false;
-                }
-                return name_to_layer[a.first]->getID() <
-                       name_to_layer[b.first]->getID();
-              });
+      if (!name_to_layer.contains(a.first) ||
+          !name_to_layer.contains(b.first)) {
+        return false;
+      }
+      return name_to_layer[a.first]->getID() < name_to_layer[b.first]->getID();
+    });
 
   } catch (const std::exception& e) {
     std::cerr << "ERROR during sorting: " << e.what() << '\n';
@@ -296,7 +313,9 @@ ParseResult parse_json_model(RuntimeOptions options,
     }
   }
 
-  if (comments) std::cout << "Loaded model data from JSON." << '\n';
+  if (comments) {
+    std::cout << "Loaded model data from JSON." << '\n';
+  }
 
   auto input_layer = std::make_shared<it_lab_ai::InputLayer>(it_lab_ai::kNchw,
                                                              it_lab_ai::kNchw);
@@ -309,7 +328,9 @@ ParseResult parse_json_model(RuntimeOptions options,
     try {
       std::string layer_type = layer_data["type"];
 
-      if (layer_type == "InputLayer") continue;
+      if (layer_type == "InputLayer") {
+        continue;
+      }
       std::string layer_name = layer_data["name"];
       int layer_index = layer_data["index"];
       if (comments) {
@@ -703,7 +724,9 @@ ParseResult parse_json_model(RuntimeOptions options,
           std::cout << "TransposeLayer added with perm: [";
           for (size_t i = 0; i < perm.size(); ++i) {
             std::cout << perm[i];
-            if (i < perm.size() - 1) std::cout << ", ";
+            if (i < perm.size() - 1) {
+              std::cout << ", ";
+            }
           }
           std::cout << "]" << '\n';
         }

app/Graph/build.hpp

@@ -61,7 +61,8 @@ void build_graph(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
                  it_lab_ai::RuntimeOptions options, bool comments);
 void build_graph_linear(it_lab_ai::Graph& graph, it_lab_ai::Tensor& input,
                         it_lab_ai::Tensor& output,
-                        it_lab_ai::RuntimeOptions options, bool comments);
+                        it_lab_ai::RuntimeOptions options, bool comments,
+                        bool enable_postops = true);
 std::unordered_map<int, std::string> load_class_names(
     const std::string& filename);
 

app/Graph/graph_build.cpp

@@ -181,4 +181,4 @@ int main(int argc, char* argv[]) {
     }
   }
   return 0;
-}
+}

app/Graph/onnx_subgraphs.cpp

@@ -1,26 +1,83 @@
 #include <algorithm>
 #include <filesystem>
 #include <iomanip>
+#include <iostream>
 #include <numeric>
+#include <opencv2/opencv.hpp>
 #include <sstream>
 #include <unordered_map>
 
 #include "build.hpp"
 #include "graph_transformations/graph_transformations.hpp"
+#include "layers_fused/ConvRelu.hpp"
 #include "perf/benchmarking.hpp"
 
 using namespace it_lab_ai;
 
+void alexnet_inf_careless(Graph& graph, const RuntimeOptions& options,
+                          Tensor& input, Tensor& output) {
+  if (graph.getLayersCount() == 0) {
+    throw std::runtime_error("No layers");
+  }
+  graph.setInput(graph.getLayerFromID(0), input);
+  graph.setOutput(graph.getLayerFromID(graph.getLayersCount() - 1), output);
+  graph.inference(options);
+}
+
+void alexnet_comparison() {
+  std::vector<size_t> counts = {979, 1134, 1031, 1009, 981,
+                                891, 957,  1027, 973,  1008};
+  size_t sum = std::accumulate(counts.begin(), counts.end(), size_t{0});
+  int count_pic = static_cast<int>(sum) + 10;
+  std::vector<float> res(count_pic * 28 * 28, 1.0F);
+  Tensor input;
+  Shape sh1({1, 5, 5, 3});
+  std::vector<float> vec;
+  vec.reserve(75);
+  for (int i = 0; i < 75; ++i) {
+    vec.push_back(3);
+  }
+  Tensor output = make_tensor(vec, sh1);
+
+  Shape sh({static_cast<size_t>(count_pic), 1, 28, 28});
+  Tensor t = make_tensor<float>(res, sh);
+  input = t;
+
+  RuntimeOptions options;
+  Graph graph;
+  Graph graph2;
+  build_graph_linear(graph, input, output, options, true, false);
+  Graph subgraph;
+  std::shared_ptr<Layer> layer_0 = std::make_shared<ConvolutionalLayer>();
+  std::shared_ptr<Layer> layer_1 = std::make_shared<EWLayer>("relu");
+  subgraph.setInput(layer_0, input);
+  subgraph.makeConnection(layer_0, layer_1);
+  std::shared_ptr<Layer> layer_to = std::make_shared<ConvReluLayer>(
+      std::dynamic_pointer_cast<ConvolutionalLayer>(layer_0));
+  changed_subgraphs(graph, subgraph, layer_to, graph2, input, options);
+  Tensor input_c = input;
+  Tensor output_c = output;
+  auto time1 = elapsed_time_avg<double, std::milli>(
+      4, alexnet_inf_careless, graph, options, input_c, output_c);
+  print_time_stats(graph);
+  auto time2 = elapsed_time_avg<double, std::milli>(
+      4, alexnet_inf_careless, graph2, options, input_c, output_c);
+  print_time_stats(graph2);
+  std::cout << time1 << " for unchanged graph\n";
+  std::cout << time2 << " for convrelu graph\n";
+}
+
 int main() {
   int type = 2;
   Tensor input = make_tensor(std::vector<int>({0}));
   RuntimeOptions options;
+  alexnet_comparison();
   if (type == 0) {
     Graph graph1;
     build_graph(graph1, input, input, MODEL_PATH_DENSENET_ONNX, options, false);
 
     Graph subgraph;
-    Tensor scale = make_tensor(std::vector<float>({1.0}));
+    Tensor scale = make_tensor(std::vector<float>({1.0F}));
     std::shared_ptr<Layer> layer_0 =
         std::make_shared<BatchNormalizationLayer>(scale, scale, scale, scale);
     std::shared_ptr<Layer> layer_1 = std::make_shared<EWLayer>("relu");