Tidy

Author: NeiroYT

app/Graph/onnx_subgraphs.cpp

@@ -16,8 +16,8 @@ using namespace it_lab_ai;
 
 void alexnet_inf_careless(Graph& graph, const RuntimeOptions& options,
                           Tensor& input, Tensor& output) {
-  Tensor* o = new Tensor(output);
-  Tensor* i = new Tensor(input);
+  auto* o = new Tensor(output);
+  auto* i = new Tensor(input);
   graph.inference(options);
   graph.setOutput(*o);
   graph.setInput(*i);
@@ -28,7 +28,7 @@ void alexnet_comparison() {
                                 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);
+  std::vector<float> res(count_pic * 28 * 28, 1.0F);
   Tensor input;
   Shape sh1({1, 5, 5, 3});
   std::vector<float> vec;
@@ -43,21 +43,21 @@ void alexnet_comparison() {
   input = t;
 
   RuntimeOptions options;
-  Graph graph1;
+  Graph graph;
   Graph graph2;
-  build_graph_linear(graph1, input, output, options, true);
+  build_graph_linear(graph, input, output, options, true);
   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(graph1, subgraph, layer_to, graph2, input, options);
+  changed_subgraphs(graph, subgraph, layer_to, graph2, input, options);
   Tensor input_c = input;
   Tensor output_c = output;
   double time1 = elapsed_time_avg<double, std::milli>(
-      2, alexnet_inf_careless, graph1, options, input_c, output_c);
+      2, alexnet_inf_careless, graph, options, input_c, output_c);
   double time2 = elapsed_time_avg<double, std::milli>(
       2, alexnet_inf_careless, graph2, options, input_c, output_c);
   std::cout << time1 << " for unchanged graph\n";
@@ -74,7 +74,7 @@ int main() {
     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");

include/layers/ConvLayer.hpp

@@ -59,17 +59,17 @@ class ConvolutionalLayer : public Layer {
     useLegacyImpl_ = useLegacyImpl;
   }
 
-  std::vector<size_t> get_numeric_params() {
+  std::vector<size_t> getNumericParams() const {
     std::vector<size_t> res = {stride_, pads_, dilations_, group_};
     return res;
   }
 
-  std::vector<std::shared_ptr<Tensor>> get_tensor_params() {
+  std::vector<std::shared_ptr<Tensor>> getTensorParams() {
     std::vector<std::shared_ptr<Tensor>> res = {kernel_, bias_};
     return res;
   }
 
-  bool getLegacyImplBool() { return useLegacyImpl_; }
+  bool getLegacyImplBool() const { return useLegacyImpl_; }
 
   void run(const std::vector<Tensor>& input,
            std::vector<Tensor>& output) override;

include/layers_fused/ConvRelu.hpp

@@ -61,8 +61,8 @@ class ConvReluLayer : public Layer {
   }
   ConvReluLayer(const std::shared_ptr<ConvolutionalLayer>& conv)
       : Layer(kConvRelu) {
-    auto numerics = conv->get_numeric_params();
-    auto tensors = conv->get_tensor_params();
+    auto numerics = conv->getNumericParams();
+    auto tensors = conv->getTensorParams();
     stride_ = numerics[0];
     pads_ = numerics[1];
     dilations_ = numerics[2];

test/graph/test_graph.cpp

@@ -32,6 +32,44 @@
 
 using namespace it_lab_ai;
 
+TEST(graph, test_new_setInput) {
+  const std::vector<float> vec1 = {2.0F, 1.5F, 0.1F, 1.9F, 0.0F, 5.5F};
+  Tensor weights = make_tensor<float>(vec1, {3, 2});
+  Tensor bias = make_tensor<float>({0.5F, 0.5F, 1.0F});
+  Tensor input = make_tensor<float>({1.0F, 2.0F}, {2});
+  Tensor output;
+  Graph graph;
+
+  auto fcLayer = std::make_shared<FCLayer>(weights, bias);
+  auto inputLayer = std::make_shared<InputLayer>();
+  auto ewLayer = std::make_shared<EWLayer>();
+
+  graph.addSingleLayer(inputLayer);
+  graph.makeConnection(inputLayer, fcLayer);
+  graph.makeConnection(fcLayer, ewLayer);
+
+  ASSERT_NO_THROW(graph.setInput(input));
+}
+
+TEST(graph, test_new_setOutput) {
+  const std::vector<float> vec1 = {2.0F, 1.5F, 0.1F, 1.9F, 0.0F, 5.5F};
+  Tensor weights = make_tensor<float>(vec1, {3, 2});
+  Tensor bias = make_tensor<float>({0.5F, 0.5F, 1.0F});
+  Tensor input = make_tensor<float>({1.0F, 2.0F}, {2});
+  Tensor output;
+  Graph graph;
+
+  auto fcLayer = std::make_shared<FCLayer>(weights, bias);
+  auto inputLayer = std::make_shared<InputLayer>();
+  auto ewLayer = std::make_shared<EWLayer>();
+
+  graph.addSingleLayer(inputLayer);
+  graph.makeConnection(inputLayer, fcLayer);
+  graph.makeConnection(fcLayer, ewLayer);
+
+  ASSERT_NO_THROW(graph.setOutput(output));
+}
+
 TEST(graph, test_deep_copy) {
   Graph graph;
   Graph graph2;

test/single_layer/test_convlayer.cpp

@@ -7,6 +7,22 @@ using namespace it_lab_ai;
 
 class ConvTestFixture : public BaseTestFixture {};
 
+TEST(ConvolutionalLayerTest, Getters) {
+  int step = 2;
+  std::vector<float> kernelvec = {1, 0, 1, 0, 1, 0, 1, 0, 1};
+  Shape sh2({3, 3});
+  Tensor kernel = make_tensor(kernelvec, sh2);
+  ConvolutionalLayer layer(step, 0, 1, kernel);
+  std::vector<float> vec = {1, 2, 3, 4};
+  Tensor input1 = make_tensor<float>(vec, {4});
+  Tensor input2 = make_tensor<float>(vec, {2, 2});
+  std::vector<Tensor> in{input1, input2};
+  std::vector<Tensor> output{input1};
+  EXPECT_NO_THROW(layer.getLegacyImplBool());
+  EXPECT_NO_THROW(layer.getNumericParams());
+  EXPECT_NO_THROW(layer.getTensorParams());
+}
+
 TEST(ConvolutionalLayerTest, IncompatibleInput) {
   int step = 2;
   std::vector<float> kernelvec = {1, 0, 1, 0, 1, 0, 1, 0, 1};

test/single_layer_fused/test_convrelu.cpp

@@ -5,6 +5,21 @@
 
 using namespace it_lab_ai;
 
+TEST(ConvReluLayerTest, CopyFromConv) {
+  int step = 2;
+  std::vector<float> kernelvec = {1, 0, 1, 0, 1, 0, 1, 0, 1};
+  Shape sh2({3, 3});
+  Tensor kernel = make_tensor(kernelvec, sh2);
+  std::shared_ptr<ConvolutionalLayer> layer =
+      std::make_shared<ConvolutionalLayer>(step, 0, 1, kernel);
+  std::vector<float> vec = {1, 2, 3, 4};
+  Tensor input1 = make_tensor<float>(vec, {4});
+  Tensor input2 = make_tensor<float>(vec, {2, 2});
+  std::vector<Tensor> in{input1, input2};
+  std::vector<Tensor> output{input1};
+  EXPECT_NO_THROW(ConvReluLayer layer2(layer));
+}
+
 TEST(ConvReluLayerTest, IncompatibleInput) {
   int step = 2;
   std::vector<float> kernelvec = {1, 0, 1, 0, 1, 0, 1, 0, 1};