Adding 4d input logic, fixing fclayer for this, adding a new soft max for a large number of images, parallelizing convlayer (#170)

Co-authored-by: AndreySorokin7 <andrey_sorokin_nn@mail,ru>

Author: AndreySorokin7

README.md

@@ -23,15 +23,16 @@ To build and run this project locally on Windows, follow these steps:
    mkdir build
    cd build
    cmake .. -DCMAKE_BUILD_TYPE=Release
-   If you want to build in a debug, change the release to debug
     ```
-    *Note: Make sure you have CMake installed to build the project.*
-4. **Build the project:**
+   If you want to build in a Debug, change the Release to Debug
+
+   *Note: Make sure you have CMake installed to build the project.*
+5. **Build the project:**
    Next, to build the project, we will need to enter the command
     ```bash
    cmake --build . --config Release
     ```
-5. **Run the project**
+6. **Run the project**
    After building the project, you can find the executable file in the following path from the *build* folder
    ```bash
    cd app\Release
@@ -77,7 +78,7 @@ To build and run this project locally on Windows, follow these steps:
     ```bash
    cmake --build build --config Release
     ```
-    If you want to build in a debug, change the release to debug
+    If you want to build in a Debug, change the Release to Debug
 6. **Run the project**
    After building the project, you can find the executable file in the following path from the *build* folder
    ```bash

app/Graph/acc_check_mnist.cpp

@@ -11,6 +11,17 @@ int main() {
   std::vector<size_t> counts = {979, 1134, 1031, 1009, 981,
                                 891, 957,  1027, 973,  1008};
   int stat = 0;
+  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);
+  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);
 
   for (size_t name = 0; name < 10; name++) {
     for (size_t ind = 0; ind < counts[name] + 1; ind++) {
@@ -19,7 +30,6 @@ int main() {
           << ".png";
       std::string png = oss.str();
       std::string image_path = MNIST_PATH + png;
-      std::cout << image_path << std::endl;
 
       cv::Mat image = cv::imread(image_path);
       if (image.empty()) {
@@ -28,37 +38,39 @@ int main() {
       cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
       std::vector<cv::Mat> channels;
       cv::split(image, channels);
-      int count_pic = 1;
-      std::vector<float> res(count_pic * 28 * 28);
       for (int i = 0; i < 28; ++i) {
         for (int j = 0; j < 28; ++j) {
-          res[i * 28 + j] = channels[0].at<uchar>(j, i);
+          size_t a = ind;
+          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);
         }
       }
-      Shape sh({static_cast<size_t>(count_pic), 1, 28, 28});
-      Tensor t = make_tensor<float>(res, sh);
-      Tensor input = t;
-      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);
-      build_graph(input, output, false);
-      std::vector<float> tmp_output = softmax<float>(*output.as<float>());
-      for (size_t i = 0; i < tmp_output.size(); i++) {
-        if (tmp_output[i] >= 1e-6) {
-          if (i == name) stat++;
-        }
+    }
+  }
+  Shape sh({static_cast<size_t>(count_pic), 1, 28, 28});
+  Tensor t = make_tensor<float>(res, sh);
+  input = t;
+  build_graph(input, output, false);
+  std::vector<std::vector<float>> tmp_output =
+      softmax<float>(*output.as<float>(), 10);
+  std::vector<size_t> indices;
+  for (const auto& row : tmp_output) {
+    for (size_t j = 0; j < row.size(); ++j) {
+      if (row[j] >= 1e-6) {
+        indices.push_back(j);
+        break;
       }
     }
   }
-
-  size_t sum = std::accumulate(counts.begin(), counts.end(), size_t{0});
+  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++;
+    }
+  }
   double percentage =
       (static_cast<double>(stat) / static_cast<double>(sum + 10)) * 100;
   std::cout << "Stat: " << std::fixed << std::setprecision(2) << percentage
             << "%" << std::endl;
-  std::cout << percentage << std::endl;
 }

include/layers/ConvLayer.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <cmath>
 #include <stdexcept>
+#include <thread>
 #include <vector>
 
 #include "layers/Layer.hpp"
@@ -143,36 +144,58 @@ void Conv4D(const Tensor& input, const Tensor& kernel_, const Tensor& bias_,
       std::vector<std::vector<std::vector<ValueType>>>(
           in_height, std::vector<std::vector<ValueType>>(
                          in_width, std::vector<ValueType>(in_channels, 1))));
-  for (size_t n = 0; n < batch_size; n++) {
-    for (size_t c = 0; c < in_channels; c++) {
-      for (size_t h = 0; h < in_height; h++) {
-        for (size_t w = 0; w < in_width; w++) {
-          input_tensor[n][h][w][c] = input.get<ValueType>({n, c, h, w});
+
+  auto init_input = [&](size_t start_b, size_t end_b) {
+    for (size_t n = start_b; n < end_b; n++) {
+      for (size_t c = 0; c < in_channels; c++) {
+        for (size_t h = 0; h < in_height; h++) {
+          for (size_t w = 0; w < in_width; w++) {
+            input_tensor[n][h][w][c] = input.get<ValueType>({n, c, h, w});
+          }
         }
       }
     }
-  }
-  // adapt input
+  };
 
   std::vector<std::vector<std::vector<std::vector<ValueType>>>> kernel(
       kernel_height,
       std::vector<std::vector<std::vector<ValueType>>>(
           kernel_width, std::vector<std::vector<ValueType>>(
                             kernel_in_channels,
                             std::vector<ValueType>(kernel_out_channels, 1))));
-  for (size_t h = 0; h < kernel_height; h++) {
-    for (size_t w = 0; w < kernel_width; w++) {
-      for (size_t n = 0; n < kernel_in_channels; n++) {
-        for (size_t c = 0; c < kernel_out_channels; c++) {
-          kernel[h][w][n][c] = kernel_.get<ValueType>({h, w, n, c});
+
+  auto init_kernel = [&](size_t start_h, size_t end_h) {
+    for (size_t h = start_h; h < end_h; h++) {
+      for (size_t w = 0; w < kernel_width; w++) {
+        for (size_t n = 0; n < kernel_in_channels; n++) {
+          for (size_t c = 0; c < kernel_out_channels; c++) {
+            kernel[h][w][n][c] = kernel_.get<ValueType>({h, w, n, c});
+          }
         }
       }
     }
+  };
+
+  unsigned num_threads = std::thread::hardware_concurrency();
+  std::vector<std::thread> threads;
+  size_t chunk_size = batch_size / num_threads;
+
+  for (unsigned i = 0; i < num_threads; ++i) {
+    size_t start = i * chunk_size;
+    size_t end = (i == num_threads - 1) ? batch_size : start + chunk_size;
+    threads.emplace_back(init_input, start, end);
   }
-  // adapt kernel
+  for (auto& t : threads) t.join();
+  threads.clear();
 
-  // pads_ = (kernel_height * dilations_ + 1 - dilations_) / 2;
-  // ???
+  chunk_size = kernel_height / num_threads;
+  for (unsigned i = 0; i < num_threads; ++i) {
+    size_t start = i * chunk_size;
+    size_t end = (i == num_threads - 1) ? kernel_height : start + chunk_size;
+    threads.emplace_back(init_kernel, start, end);
+  }
+  for (auto& t : threads) t.join();
+  threads.clear();
 
   std::vector<std::vector<std::vector<std::vector<ValueType>>>> padded_input =
       input_tensor;
@@ -185,19 +208,28 @@ void Conv4D(const Tensor& input, const Tensor& kernel_, const Tensor& bias_,
                                 in_width + 2 * pads_,
                                 std::vector<ValueType>(in_channels, 0))));
 
-    for (size_t b = 0; b < batch_size; ++b) {
-      for (size_t h = 0; h < in_height; ++h) {
-        for (size_t w = 0; w < in_width; ++w) {
-          for (size_t c = 0; c < in_channels; ++c) {
-            padded_input[b][h + pads_][w + pads_][c] = input_tensor[b][h][w][c];
+    auto pad_input = [&](size_t start_b, size_t end_b) {
+      for (size_t b = start_b; b < end_b; ++b) {
+        for (size_t h = 0; h < in_height; ++h) {
+          for (size_t w = 0; w < in_width; ++w) {
+            for (size_t c = 0; c < in_channels; ++c) {
+              padded_input[b][h + pads_][w + pads_][c] =
+                  input_tensor[b][h][w][c];
+            }
           }
         }
       }
+    };
+
+    chunk_size = batch_size / num_threads;
+    for (unsigned i = 0; i < num_threads; ++i) {
+      size_t start = i * chunk_size;
+      size_t end = (i == num_threads - 1) ? batch_size : start + chunk_size;
+      threads.emplace_back(pad_input, start, end);
     }
+    for (auto& t : threads) t.join();
+    threads.clear();
   }
-  // | | | | |
-  // | data  |
-  // | | | | |
 
   std::vector<std::vector<std::vector<std::vector<ValueType>>>> dil_kernel =
       kernel;
@@ -210,16 +242,28 @@ void Conv4D(const Tensor& input, const Tensor& kernel_, const Tensor& bias_,
                 kernel_in_channels,
                 std::vector<ValueType>(kernel_out_channels, 0))));
 
-    for (size_t b = 0; b < kernel_out_channels; ++b) {
-      for (size_t h = 0; h < kernel_height; ++h) {
-        for (size_t w = 0; w < kernel_width; ++w) {
-          for (size_t c = 0; c < kernel_in_channels; ++c) {
-            dil_kernel[h * dilations_][w * dilations_][c][b] =
-                kernel[h][w][c][b];
+    auto dilate_kernel = [&](size_t start_b, size_t end_b) {
+      for (size_t b = start_b; b < end_b; ++b) {
+        for (size_t h = 0; h < kernel_height; ++h) {
+          for (size_t w = 0; w < kernel_width; ++w) {
+            for (size_t c = 0; c < kernel_in_channels; ++c) {
+              dil_kernel[h * dilations_][w * dilations_][c][b] =
+                  kernel[h][w][c][b];
+            }
           }
         }
       }
+    };
+
+    chunk_size = kernel_out_channels / num_threads;
+    for (unsigned i = 0; i < num_threads; ++i) {
+      size_t start = i * chunk_size;
+      size_t end =
+          (i == num_threads - 1) ? kernel_out_channels : start + chunk_size;
+      threads.emplace_back(dilate_kernel, start, end);
     }
+    for (auto& t : threads) t.join();
+    threads.clear();
   }
 
   size_t crat = 0;
@@ -231,7 +275,6 @@ void Conv4D(const Tensor& input, const Tensor& kernel_, const Tensor& bias_,
       crat;
 
   crat = 0;
-
   if ((in_width + 2 * pads_ - dilations_ * (kernel_width - 1)) % stride_ != 0)
     crat = 1;
 
@@ -244,44 +287,67 @@ void Conv4D(const Tensor& input, const Tensor& kernel_, const Tensor& bias_,
                       std::vector<std::vector<ValueType>>(
                           out_height, std::vector<ValueType>(out_width, 0))));
 
-  for (size_t b = 0; b < batch_size; ++b) {
-    for (size_t c = 0; c < kernel_out_channels; ++c) {
-      for (size_t i = 0; i < out_height; i += stride_) {
-        for (size_t j = 0; j < out_width; j += stride_) {
-          ValueType value = 0;
-          for (size_t ic = 0; ic < in_channels; ++ic) {
-            for (size_t h = 0; h < kernel_height * dilations_ + 1 - dilations_;
-                 ++h) {
-              for (size_t w = 0; w < kernel_width * dilations_ + 1 - dilations_;
-                   ++w) {
-                value +=
-                    padded_input[b][i + h][j + w][ic] * dil_kernel[h][w][ic][c];
+  auto compute_conv = [&](size_t start_b, size_t end_b) {
+    for (size_t b = start_b; b < end_b; ++b) {
+      for (size_t c = 0; c < kernel_out_channels; ++c) {
+        for (size_t i = 0; i < out_height; i += stride_) {
+          for (size_t j = 0; j < out_width; j += stride_) {
+            ValueType value = 0;
+            for (size_t ic = 0; ic < in_channels; ++ic) {
+              for (size_t h = 0;
+                   h < kernel_height * dilations_ + 1 - dilations_; ++h) {
+                for (size_t w = 0;
+                     w < kernel_width * dilations_ + 1 - dilations_; ++w) {
+                  value += padded_input[b][i + h][j + w][ic] *
+                           dil_kernel[h][w][ic][c];
+                }
               }
             }
-          }
-          if (!bias_.empty()) {
-            output_tensor[b][c][i][j] = value + (*bias_.as<ValueType>())[c];
-          } else {
-            output_tensor[b][c][i][j] = value;
+            if (!bias_.empty()) {
+              output_tensor[b][c][i][j] = value + (*bias_.as<ValueType>())[c];
+            } else {
+              output_tensor[b][c][i][j] = value;
+            }
           }
         }
       }
     }
+  };
+
+  chunk_size = batch_size / num_threads;
+  for (unsigned i = 0; i < num_threads; ++i) {
+    size_t start = i * chunk_size;
+    size_t end = (i == num_threads - 1) ? batch_size : start + chunk_size;
+    threads.emplace_back(compute_conv, start, end);
   }
+  for (auto& t : threads) t.join();
+  threads.clear();
 
   Shape sh({batch_size, kernel_out_channels, out_height, out_width});
   std::vector<ValueType> one_d_vector(batch_size * out_height * out_width *
                                       kernel_out_channels);
-  size_t index_1d = 0;
-  for (size_t i = 0; i < batch_size; ++i) {
-    for (size_t l = 0; l < kernel_out_channels; ++l) {
-      for (size_t j = 0; j < out_height; ++j) {
-        for (size_t k = 0; k < out_width; ++k) {
-          one_d_vector[index_1d++] = output_tensor[i][l][j][k];
+
+  auto flatten_output = [&](size_t start_b, size_t end_b) {
+    size_t index_1d = start_b * kernel_out_channels * out_height * out_width;
+    for (size_t i = start_b; i < end_b; ++i) {
+      for (size_t l = 0; l < kernel_out_channels; ++l) {
+        for (size_t j = 0; j < out_height; ++j) {
+          for (size_t k = 0; k < out_width; ++k) {
+            one_d_vector[index_1d++] = output_tensor[i][l][j][k];
+          }
         }
       }
     }
+  };
+
+  chunk_size = batch_size / num_threads;
+  for (unsigned i = 0; i < num_threads; ++i) {
+    size_t start = i * chunk_size;
+    size_t end = (i == num_threads - 1) ? batch_size : start + chunk_size;
+    threads.emplace_back(flatten_output, start, end);
   }
+  for (auto& t : threads) t.join();
+
   output = make_tensor<ValueType>(one_d_vector, sh);
 }