Merge branch 'main' into Semyon1104/Owner_Graph

Author: Semyon1104

.clang-tidy

@@ -27,7 +27,6 @@ Checks: >
   -bugprone-easily-swappable-parameters,
   -bugprone-implicit-widening-of-multiplication-result,
   -bugprone-unchecked-optional-access,
-  -clang-analyzer-security.insecureAPI.rand,
 
 WarningsAsErrors: "*"
 

.github/workflows/static-analysis.yml

@@ -12,20 +12,6 @@ jobs:
     - name: Install prerequisites
       run: |
         sudo apt install clang libomp-dev
-    - name: Download and extract TensorFlow
-      run: |
-         wget https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-linux-x86_64-2.7.0.tar.gz
-         tar -xzvf libtensorflow-cpu-linux-x86_64-2.7.0.tar.gz
-    - name: Set TensorFlow environment variables
-      run: |
-         echo "TensorFlow_INCLUDE_DIRS=${PWD}/include" >> $GITHUB_ENV
-         echo "TensorFlow_LIBRARIES=${PWD}/lib/libtensorflow.so" >> $GITHUB_ENV
-         echo "export TensorFlow_INCLUDE_DIRS=${PWD}/include" >> $GITHUB_ENV
-         echo "export TensorFlow_LIBRARIES=${PWD}/lib/libtensorflow.so" >> $GITHUB_ENV
-    - name: Display TensorFlow environment variables
-      run: |
-         echo "TensorFlow_INCLUDE_DIRS: ${{ env.TensorFlow_INCLUDE_DIRS }}"
-         echo "TensorFlow_LIBRARIES: ${{ env.TensorFlow_LIBRARIES }}"
     - name: Setup ccache
       uses: hendrikmuhs/ccache-action@v1.2
       with:
@@ -37,9 +23,7 @@ jobs:
             -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
             -DCMAKE_C_COMPILER=clang \
             -DCMAKE_CXX_COMPILER=clang++ \
-            -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
-            -DTensorFlow_INCLUDE_DIRS=$TensorFlow_INCLUDE_DIRS \
-            -DTensorFlow_LIBRARIES=$TensorFlow_LIBRARIES
+            -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
             cmake --build build --parallel
     - name: Run clang-tidy
       run: |

app/Converters/requirements.txt

@@ -1,5 +1,9 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+
 tensorflow>=2.19.0
 onnx>=1.15.0
+torch==2.2.1+cpu
+torchvision==0.17.1+cpu
 ultralytics>=8.0.0
 numpy>=1.21.0
 protobuf>=3.20.0

test/benchmarking/test_accuracy.cpp

@@ -33,11 +33,13 @@ TEST(accuracy, bad_accuracy_test_L) {
   size_t n = 5000;
   double a[5000];
   double b[5000];
+  std::mt19937 rng(42);
+  std::uniform_real_distribution<double> dist(-100.0, 100.0);
   for (size_t i = 0; i < n; i++) {
-    a[i] = (static_cast<double>(rand()) / RAND_MAX - 1.0) * 100;  // [-100;100]
+    a[i] = dist(rng);
   }
   for (size_t i = 0; i < n; i++) {
-    b[i] = (static_cast<double>(rand()) / RAND_MAX - 1.0) * 100;  // [-100;100]
+    b[i] = dist(rng);
   }
   double actual_acc = 0.0;
   for (size_t i = 0; i < n; i++) {
@@ -67,11 +69,13 @@ TEST(accuracy, bad_accuracy_norm_test_L) {
   size_t n = 5000;
   double a[5000];
   double b[5000];
+  std::mt19937 rng2(42);
+  std::uniform_real_distribution<double> dist2(-100.0, 100.0);
   for (size_t i = 0; i < n; i++) {
-    a[i] = (static_cast<double>(rand()) / RAND_MAX - 1.0) * 100;  // [-100;100]
+    a[i] = dist2(rng2);
   }
   for (size_t i = 0; i < n; i++) {
-    b[i] = (static_cast<double>(rand()) / RAND_MAX - 1.0) * 100;  // [-100;100]
+    b[i] = dist2(rng2);
   }
   double actual_acc = 0.0;
   for (size_t i = 0; i < n; i++) {

test/benchmarking/test_layers_time.cpp

@@ -23,8 +23,10 @@ TEST(pooling_test, is_pooling_tbb_ok) {
   size_t w = 224;
   Shape test_shape = {n, c, h, w};
   std::vector<int> a1(n * c * h * w);
+  std::mt19937 rng(42);
+  std::uniform_int_distribution<int> dist(0, std::numeric_limits<int>::max());
   for (size_t i = 0; i < n * c * h * w; i++) {
-    a1[i] = rand();
+    a1[i] = dist(rng);
   }
   Tensor input = make_tensor(a1, test_shape);
   Tensor output;
@@ -45,11 +47,13 @@ TEST(conv_test, is_conv_stl_ok) {
   Shape test_shape = {n, c, h, w};
   std::vector<int> a1(n * c * h * w);
   std::vector<int> a2(3 * 25 * 16);
+  std::mt19937 rng2(42);
+  std::uniform_int_distribution<int> dist2(0, std::numeric_limits<int>::max());
   for (size_t i = 0; i < n * c * h * w; i++) {
-    a1[i] = rand();
+    a1[i] = dist2(rng2);
   }
   for (size_t i = 0; i < 3 * 25 * 16; i++) {
-    a2[i] = rand();
+    a2[i] = dist2(rng2);
   }
   Tensor input = make_tensor(a1, test_shape);
   Tensor kernel = make_tensor(a2, Shape({5, 5, 3, 16}));

test/graph/test_graph.cpp

@@ -586,11 +586,14 @@ TEST(graph_transformations, check_subgraphs_big_random) {
     layers.push_back(std::make_unique<EWLayer>("relu"));
     layer_ptrs.push_back(layers.back().get());
   }
+  graph.setInput(layers[0], input);
+  std::mt19937 rng(42);
+  std::uniform_int_distribution<int> first_dist(0, num_vertices - 2);
+  std::uniform_int_distribution<int> second_dist(1, num_vertices - 1);
 
-  graph.setInput(layer_ptrs[0], input);
   for (int i = 0; i < num_vertices; i++) {
-    int rFirst = rand() % (num_vertices - 1);
-    int rSecond = 1 + rand() % (num_vertices - 1);
+    int rFirst = first_dist(rng);
+    int rSecond = second_dist(rng);
     if ((rFirst == rSecond) ||
         ((layer_ptrs[rFirst]->getID() == layer_ptrs[rSecond]->getID()) &&
          (layer_ptrs[rFirst]->getID() != 0))) {

test/single_layer/test_outputlayer.cpp

@@ -1,6 +1,6 @@
-#include <cstdlib>
 #include <fstream>
 #include <iostream>
+#include <random>
 #include <string>
 
 #include "gtest/gtest.h"
@@ -62,8 +62,10 @@ TEST(OutputLayer, can_get_topk_with_vector) {
                  labels);
   std::vector<double> input;
   // get random nums
+  std::mt19937 rng(42);
+  std::uniform_real_distribution<double> dist01(0.0, 1.0);
   for (size_t i = 0; i < labels.size(); i++) {
-    input.push_back(static_cast<double>(std::rand()) / RAND_MAX);
+    input.push_back(dist01(rng));
   }
   ASSERT_NO_THROW(auto topk1 = top_k_vec(input, labels, k));
 }
@@ -75,9 +77,10 @@ TEST(OutputLayer, can_get_topk_with_layer_float) {
                  labels);
   std::vector<float> input;
   // get random nums
+  std::mt19937 rng2(42);
+  std::uniform_real_distribution<float> dist01f(0.0F, 1.0F);
   for (size_t i = 0; i < labels.size(); i++) {
-    input.push_back(
-        static_cast<float>(static_cast<double>(std::rand()) / RAND_MAX));
+    input.push_back(dist01f(rng2));
   }
   Tensor input_tensor = make_tensor(input);
   OutputLayer layer(labels);
@@ -91,8 +94,11 @@ TEST(OutputLayer, can_get_topk_with_layer_int) {
                  labels);
   std::vector<int> input;
   // get random nums
+  std::mt19937 rng3(42);
+  std::uniform_int_distribution<int> dist_int(0,
+                                              std::numeric_limits<int>::max());
   for (size_t i = 0; i < labels.size(); i++) {
-    input.push_back(std::rand());
+    input.push_back(dist_int(rng3));
   }
   Tensor input_tensor = make_tensor(input);
   OutputLayer layer(labels);
@@ -106,8 +112,11 @@ TEST(OutputLayer, topk_throws_when_not_1d_input) {
                  labels);
   std::vector<int> input;
   // get random nums
+  std::mt19937 rng4(42);
+  std::uniform_int_distribution<int> dist_int2(0,
+                                               std::numeric_limits<int>::max());
   for (size_t i = 0; i < labels.size(); i++) {
-    input.push_back(std::rand());
+    input.push_back(dist_int2(rng4));
   }
   Tensor input_tensor = make_tensor(input, {5, 200});
   OutputLayer layer(labels);
@@ -121,8 +130,11 @@ TEST(OutputLayer, topk_throws_when_incorrect_input_size) {
                  labels);
   std::vector<int> input;
   // get random nums
+  std::mt19937 rng5(42);
+  std::uniform_int_distribution<int> dist_int3(0,
+                                               std::numeric_limits<int>::max());
   for (size_t i = 0; i < 20; i++) {
-    input.push_back(std::rand());
+    input.push_back(dist_int3(rng5));
   }
   Tensor input_tensor = make_tensor(input);
   OutputLayer layer(labels);
@@ -136,8 +148,11 @@ TEST(OutputLayer, topk_throws_when_too_big_k) {
                  labels);
   std::vector<int> input;
   // get random nums
+  std::mt19937 rng6(42);
+  std::uniform_int_distribution<int> dist_int4(0,
+                                               std::numeric_limits<int>::max());
   for (size_t i = 0; i < labels.size(); i++) {
-    input.push_back(std::rand());
+    input.push_back(dist_int4(rng6));
   }
   Tensor input_tensor = make_tensor(input);
   OutputLayer layer(labels);

test/single_layer/test_poolinglayer.cpp

@@ -1,4 +1,5 @@
-#include <vector>
+#include <random>
+#include <vector>
 
 #include "gtest/gtest.h"
 #include "layers/PoolingLayer.hpp"
@@ -365,9 +366,10 @@ TEST(poolinglayer, maxpool_onnx_example) {
   EXPECT_EQ(impl.get_output_shape(), expected_output_shape);
 
   std::vector<float> input(input_shape.count());
+  std::mt19937 rng(42);
+  std::uniform_real_distribution<float> dist(0.0F, 10.0F);
   for (size_t i = 0; i < input.size(); i++) {
-    input[i] =
-        static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * 10.0f;
+    input[i] = dist(rng);
   }
 
   std::vector<float> output = impl.run(input);
@@ -403,9 +405,10 @@ TEST(poolinglayer, maxpool_onnx_with_pooling_layer) {
   PoolingLayer layer(poolshape, strides, pads, dilations, ceil_mode, "max");
 
   std::vector<float> input(input_shape.count());
+  std::mt19937 rng2(42);
+  std::uniform_real_distribution<float> dist2(0.0F, 10.0F);
   for (size_t i = 0; i < input.size(); i++) {
-    input[i] =
-        static_cast<float>(rand()) / static_cast<float>(RAND_MAX) * 10.0f;
+    input[i] = dist2(rng2);
   }
 
   Tensor input_tensor = make_tensor(input, input_shape);