batch 32 for accuracy

Author: Semyon1104

app/Graph/acc_check.cpp

@@ -1,4 +1,14 @@
-#include <algorithm>
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <psapi.h>
+#pragma comment(lib, "psapi.lib")
+#include <crtdbg.h>
+#include <algorithm>
+#include <chrono>
+#include <cmath>
 #include <filesystem>
 #include <iomanip>
 #include <numeric>
@@ -7,17 +17,82 @@
 
 #include "build.hpp"
 
+class MemoryLogger {
+ private:
+  std::chrono::steady_clock::time_point start_time;
+  size_t peak_memory = 0;
+  size_t initial_memory = 0;
+
+  size_t getProcessMemory() {
+    HANDLE hProcess = GetCurrentProcess();
+    PROCESS_MEMORY_COUNTERS pmc;
+    pmc.cb = sizeof(PROCESS_MEMORY_COUNTERS);
+
+    if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) {
+      return pmc.WorkingSetSize / (1024 * 1024);
+    }
+    return 0;
+  }
+
+ public:
+  MemoryLogger() {
+    start_time = std::chrono::steady_clock::now();
+    initial_memory = getProcessMemory();
+    log("START");
+  }
+
+  void log(const char* stage) {
+    auto now = std::chrono::steady_clock::now();
+    auto elapsed =
+        std::chrono::duration_cast<std::chrono::seconds>(now - start_time)
+            .count();
+
+    size_t current = getProcessMemory();
+    if (current > peak_memory) peak_memory = current;
+
+    std::cout << "[" << std::setw(4) << elapsed << "s] " << std::setw(30)
+              << stage << " | "
+              << "PROCESS MEM: " << std::setw(6) << current << " MB"
+              << " (PEAK: " << std::setw(6) << peak_memory << " MB)"
+              << " (DELTA: " << std::setw(4) << (current - initial_memory)
+              << " MB)\n";
+  }
+
+  ~MemoryLogger() {
+    log("END");
+    std::cout << "====================================\n";
+    std::cout << "PEAK PROCESS MEMORY: " << peak_memory << " MB\n";
+    std::cout << "INITIAL PROCESS MEMORY: " << initial_memory << " MB\n";
+    std::cout << "FINAL PROCESS MEMORY: " << getProcessMemory() << " MB\n";
+    if (getProcessMemory() > initial_memory + 10) {
+      std::cout << "WARNING: Process memory growth! (+"
+                << (getProcessMemory() - initial_memory) << " MB)\n";
+    } else {
+      std::cout << "OK: No significant process memory growth\n";
+    }
+  }
+};
+
+MemoryLogger g_memLogger;
+
+#define LOG_MEM(stage) g_memLogger.log(stage)
+
 namespace fs = std::filesystem;
 using namespace it_lab_ai;
 
 int main(int argc, char* argv[]) {
+  LOG_MEM("Program start");
+
   std::string model_name = "alexnet_mnist";
   RuntimeOptions options;
   size_t num_photo = 1000;
+  size_t batch_size = 32;
 
   for (int i = 1; i < argc; ++i) {
     if (std::string(argv[i]) == "--model" && i + 1 < argc) {
       model_name = argv[++i];
+    } else if (std::string(argv[i]) == "--batch" && i + 1 < argc) {
+      batch_size = std::stoi(argv[++i]);
     } else if (std::string(argv[i]) == "--onednn") {
       options.backend = Backend::kOneDnn;
       if (options.par_backend != ParBackend::kSeq) {
@@ -64,6 +139,8 @@ int main(int argc, char* argv[]) {
     }
   }
 
+  LOG_MEM("After args parsing");
+
   std::string dataset_path;
   if (model_name == "alexnet_mnist") {
     dataset_path = MNIST_PATH;
@@ -75,8 +152,10 @@ int main(int argc, char* argv[]) {
   std::vector<int> input_shape = get_input_shape_from_json(json_path);
 
   std::cout << '\n';
-
+  int batch_count = 0;
   if (model_name == "alexnet_mnist") {
+    LOG_MEM("MNIST start");
+
     std::vector<size_t> counts = {979, 1134, 1031, 1009, 981,
                                   891, 957,  1027, 973,  1008};
     int stat = 0;
@@ -144,15 +223,20 @@ int main(int argc, char* argv[]) {
         (static_cast<double>(stat) / static_cast<double>(sum + 10)) * 100;
     std::cout << "Stat: " << std::fixed << std::setprecision(2) << percentage
               << "%" << '\n';
+
+    LOG_MEM("MNIST end");
     return 0;
   }
 
+  LOG_MEM("ImageNet start");
+
   std::vector<size_t> counts(1000, 0);
   std::vector<std::string> image_paths;
   std::vector<int> true_labels;
   std::vector<float> all_image_data;
   size_t total_images = 0;
 
+  LOG_MEM("Counting classes");
   for (int class_id = 0; class_id < 1000; ++class_id) {
     std::ostringstream folder_oss;
     folder_oss << std::setw(5) << std::setfill('0') << class_id;
@@ -176,13 +260,16 @@ int main(int argc, char* argv[]) {
   int height = input_shape[2];
   int width = input_shape[3];
   size_t image_size = channels * height * width;
+  size_t output_classes = 1000;
 
+  LOG_MEM("Reserving memory");
   all_image_data.reserve(num_photo * image_size);
   image_paths.reserve(num_photo);
   true_labels.reserve(num_photo);
 
   total_images = 0;
 
+  LOG_MEM("Loading images start");
   for (int class_id = 0; class_id < 1000; ++class_id) {
     size_t need_from_class = images_per_class_base;
     if (remaining > 0) {
@@ -230,72 +317,148 @@ int main(int argc, char* argv[]) {
       std::cout << "Warning: Class " << class_id << " has only " << taken
                 << " images (needed " << need_from_class << ")" << '\n';
     }
+
+    if (class_id % 100 == 0 && class_id > 0) {
+      char buf[50];
+      sprintf(buf, "Class %d", class_id);
+      LOG_MEM(buf);
+    }
   }
 
+  LOG_MEM("Images loaded");
+
   if (total_images != num_photo) {
     std::cout << "Warning: Requested " << num_photo << " images but loaded "
               << total_images << " due to insufficient data" << '\n';
     num_photo = total_images;
   }
 
-  it_lab_ai::Shape input_shape_imagenet(
-      {num_photo, static_cast<size_t>(channels), static_cast<size_t>(height),
-       static_cast<size_t>(width)});
-  it_lab_ai::Tensor input =
-      it_lab_ai::make_tensor(all_image_data, input_shape_imagenet);
-
-  size_t output_classes = 1000;
-  it_lab_ai::Shape output_shape({num_photo, output_classes});
-  it_lab_ai::Tensor output =
-      it_lab_ai::Tensor(output_shape, it_lab_ai::Type::kFloat);
-
-  Graph graph;
-  build_graph(graph, input, output, json_path, options, false);
-  graph.inference(options);
-  print_time_stats(graph);
-
-  std::vector<std::vector<float>> processed_outputs;
-  const std::vector<float>& raw_output = *output.as<float>();
-
-  for (size_t i = 0; i < num_photo; ++i) {
-    std::vector<float> single_output(
-        raw_output.begin() + i * output_classes,
-        raw_output.begin() + (i + 1) * output_classes);
-    std::vector<float> processed_output =
-        process_model_output(single_output, model_name);
-    processed_outputs.push_back(processed_output);
-  }
-
   int correct_predictions_top1 = 0;
   int correct_predictions_top5 = 0;
-  for (size_t i = 0; i < processed_outputs.size(); ++i) {
-    int true_label = true_labels[i];
-    const std::vector<float>& probabilities = processed_outputs[i];
-
-    std::vector<size_t> indices(probabilities.size());
-    std::iota(indices.begin(), indices.end(), 0);
-    std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b) {
-      return probabilities[a] > probabilities[b];
-    });
-
-    size_t predicted_class_top1 = indices[0];
-    if (predicted_class_top1 == static_cast<size_t>(true_label)) {
-      correct_predictions_top1++;
-    }
 
-    bool found_in_top5 = false;
-    for (int top_k = 0; top_k < std::min(5, static_cast<int>(indices.size()));
-         ++top_k) {
-      if (indices[top_k] == static_cast<size_t>(true_label)) {
-        found_in_top5 = true;
-        break;
+  LOG_MEM("Starting batch processing");
+  auto total_start_time = std::chrono::high_resolution_clock::now();
+  int total_inference_time = 0;
+
+  for (size_t batch_start = 0; batch_start < num_photo;
+       batch_start += batch_size) {
+    size_t batch_end = std::min(batch_start + batch_size, num_photo);
+    size_t current_batch_size = batch_end - batch_start;
+
+    char batch_log[100];
+    sprintf(batch_log, "Batch %zu/%zu (size %zu)", batch_start / batch_size + 1,
+            (num_photo + batch_size - 1) / batch_size, current_batch_size);
+    LOG_MEM(batch_log);
+
+    std::vector<float> batch_data;
+    batch_data.reserve(current_batch_size * image_size);
+
+    size_t batch_offset = batch_start * image_size;
+    batch_data.insert(batch_data.end(), all_image_data.begin() + batch_offset,
+                      all_image_data.begin() + batch_offset +
+                          current_batch_size * image_size);
+
+    it_lab_ai::Shape batch_input_shape(
+        {current_batch_size, static_cast<size_t>(channels),
+         static_cast<size_t>(height), static_cast<size_t>(width)});
+    it_lab_ai::Tensor batch_input = make_tensor(batch_data, batch_input_shape);
+
+    it_lab_ai::Shape batch_output_shape({current_batch_size, output_classes});
+    it_lab_ai::Tensor batch_output(batch_output_shape, it_lab_ai::Type::kFloat);
+
+    Graph graph;
+    build_graph(graph, batch_input, batch_output, json_path, options, false);
+
+    LOG_MEM("Batch inference");
+    // auto batch_start_time =
+    //     std::chrono::high_resolution_clock::now();
+    graph.inference(options);
+    total_inference_time += print_time_stats(graph);
+    // auto batch_end_time = std::chrono::high_resolution_clock::now();
+    // int batch_time =
+    //     static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(
+    //                          batch_end_time - batch_start_time)
+    //                          .count());  // ← Добавлен static_cast
+    // total_inference_time += batch_time;
+    // batch_count++;
+
+    // #ifdef ENABLE_STATISTIC_TIME
+    //          std::vector<int> elps_time = graph.getTime();
+    //          int batch_time = std::accumulate(elps_time.begin(),
+    //          elps_time.end(), 0); total_inference_time += batch_time;
+    //          batch_count++;
+    //
+    //          char time_log[100];
+    //          sprintf(time_log, "Batch %d time: %d ms", batch_count,
+    //          batch_time); LOG_MEM(time_log);
+    // #endif
+
+    const std::vector<float>& raw_batch_output = *batch_output.as<float>();
+
+    for (size_t i = 0; i < current_batch_size; ++i) {
+      size_t global_idx = batch_start + i;
+
+      std::vector<float> single_output(
+          raw_batch_output.begin() + i * output_classes,
+          raw_batch_output.begin() + (i + 1) * output_classes);
+
+      float max_val =
+          *std::max_element(single_output.begin(), single_output.end());
+      float sum = 0.0f;
+      for (float& val : single_output) {
+        val = exp(val - max_val);
+        sum += val;
+      }
+      for (float& val : single_output) {
+        val /= sum;
+      }
+
+      std::vector<size_t> indices(single_output.size());
+      std::iota(indices.begin(), indices.end(), 0);
+      std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b) {
+        return single_output[a] > single_output[b];
+      });
+
+      if (indices[0] == static_cast<size_t>(true_labels[global_idx])) {
+        correct_predictions_top1++;
+      }
+
+      for (int top_k = 0; top_k < std::min(5, static_cast<int>(indices.size()));
+           ++top_k) {
+        if (indices[top_k] == static_cast<size_t>(true_labels[global_idx])) {
+          correct_predictions_top5++;
+          break;
+        }
       }
     }
-    if (found_in_top5) {
-      correct_predictions_top5++;
-    }
+
+    batch_data.clear();
+    batch_data.shrink_to_fit();
   }
 
+  auto total_end_time = std::chrono::high_resolution_clock::now();
+  int total_time =
+      static_cast<int>(std::chrono::duration_cast<std::chrono::milliseconds>(
+                           total_end_time - total_start_time)
+                           .count());
+
+  std::cout << "\n!INFERENCE TIME INFO START!" << '\n';
+  std::cout << "Total inference time (sum of batches): " << total_inference_time
+            << " ms\n";
+  std::cout << "Total wall-clock time for all batches: " << total_time
+            << " ms\n";
+  std::cout << "Number of batches: " << batch_count << '\n';
+  std::cout << "Average time per batch: "
+            << (batch_count > 0 ? total_inference_time / batch_count : 0)
+            << " ms\n";
+  std::cout << "!INFERENCE TIME INFO END!" << '\n';
+  /*std::cout << "\n!INFERENCE TIME INFO START!" << '\n';
+  std::cout << "Total inference time for all batches: " << total_inference_time
+            << " ms\n";
+  std::cout << "Number of batches: " << batch_count << '\n';
+  std::cout << "!INFERENCE TIME INFO END!" << '\n';
+  LOG_MEM("All batches processed");*/
+
   double final_accuracy_top1 =
       (static_cast<double>(correct_predictions_top1) / num_photo) * 100;
   double final_accuracy_top5 =
@@ -305,6 +468,7 @@ int main(int argc, char* argv[]) {
   std::cout << "Model: " << model_name << '\n';
   std::cout << "Dataset: " << dataset_path << '\n';
   std::cout << "Total images: " << num_photo << '\n';
+  std::cout << "Batch size: " << batch_size << '\n';
   std::cout << "Correct predictions (Top-1): " << correct_predictions_top1
             << '\n';
   std::cout << "Correct predictions (Top-5): " << correct_predictions_top5
@@ -314,5 +478,13 @@ int main(int argc, char* argv[]) {
   std::cout << "Top-5 Accuracy: " << std::fixed << std::setprecision(2)
             << final_accuracy_top5 << "%" << '\n';
 
+  all_image_data.clear();
+  all_image_data.shrink_to_fit();
+  image_paths.clear();
+  image_paths.shrink_to_fit();
+  true_labels.clear();
+  true_labels.shrink_to_fit();
+
+  LOG_MEM("Program end");
   return 0;
 }