ALL DONE

Author: Semyon1104

app/Graph/CMakeLists.txt

@@ -60,16 +60,8 @@ file(DOWNLOAD
 )
 
 file(DOWNLOAD
-    "https://storage.googleapis.com/kagglesdsdata/datasets/1513816/2500032/test_224/10008.jpg?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=databundle-worker-v2%40kaggle-161607.iam.gserviceaccount.com%2F20250916%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20250916T192850Z&X-Goog-Expires=345600&X-Goog-SignedHeaders=host&X-Goog-Signature=90e54a1e36e1b1be1cda07bcd00eb4cdcf504358bf9ce4eccdf0dc6af6adb19ab9fa82689878a3b26cea4e4295501fdba76e8e5dff3ee0aefe8220abd67ced9667d6f4538a7617bbe4e762a6f97907cab112949353f50276d1911c71dab11ce56370694756a2db16f08c8f819c2dbc8e6c11b131f08481962abfad3347a3ff94469310eb22db163b9036b81ce5efc720b2e175e9bb84beb87e849c2158830697328daa344f03f852ab7dad15c3bc13743f8f185dcfffc9898b7ee449800a188b1809d62f9caeb7343a94c24e7b0cae50abb93cd99a2ee679706eccd5cc093c5f4a9d0f096dcbe76be2c891f75541e11d28f47931cb8bef2dc2fea40ce1ffb391"
-    "${CMAKE_SOURCE_DIR}/docs/input/224/test1.png"
-    SHOW_PROGRESS
-    STATUS status_code
-    LOG log_file
-)
-
-file(DOWNLOAD
-    "https://cs13.pikabu.ru/avatars/3329/x3329282-693120225.png"
-    "${CMAKE_SOURCE_DIR}/docs/input/256/test1.png"
+    "blob:https://ru.pinterest.com/63b88674-b4a6-4ef3-85b2-ab57ef7bb8e7"
+    "${CMAKE_SOURCE_DIR}/docs/input/Imagenet_test/tench.png"
     SHOW_PROGRESS
     STATUS status_code
     LOG log_file

app/Graph/acc_check_mnist.cpp

@@ -55,7 +55,7 @@ int main(int argc, char* argv[]) {
   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, parallel);
+  build_graph_linear(input, output, false, parallel);
   std::vector<std::vector<float>> tmp_output =
       softmax<float>(*output.as<float>(), 10);
   std::vector<size_t> indices;

app/Graph/build.cpp

@@ -5,8 +5,7 @@
 #include <unordered_map>
 #include <unordered_set>
 
-void build_graph_linear(it_lab_ai::Tensor& input, it_lab_ai::Tensor& output,
-                        const std::string& json_path, bool comments,
+void build_graph_linear(it_lab_ai::Tensor& input, it_lab_ai::Tensor& output, bool comments,
                         bool parallel) {
   if (comments) {
     for (size_t i = 0; i < input.get_shape().dims(); i++) {
@@ -32,7 +31,7 @@ void build_graph_linear(it_lab_ai::Tensor& input, it_lab_ai::Tensor& output,
   std::vector<std::shared_ptr<it_lab_ai::Layer>> layers;
   std::vector<bool> layerpostop;
 
-  std::string json_file = json_path;
+  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." << std::endl;
@@ -78,7 +77,7 @@ void build_graph_linear(it_lab_ai::Tensor& input, it_lab_ai::Tensor& output,
       it_lab_ai::Tensor tmp_values = tensor;
       it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
       auto conv_layer = std::make_shared<it_lab_ai::ConvolutionalLayer>(
-          1, pads, 1, tmp_values, tmp_bias, impl2, 1);
+          1, pads, 1, tmp_values, tmp_bias, impl2, 1, true);
       conv_layer->setName(it_lab_ai::kConvolution);
       layers.push_back(conv_layer);
       layerpostop.push_back(false);
@@ -94,18 +93,6 @@ void build_graph_linear(it_lab_ai::Tensor& input, it_lab_ai::Tensor& output,
     }
     if (layer_type.find("Dense") != std::string::npos) {
       it_lab_ai::Tensor tmp_bias = it_lab_ai::make_tensor(tensor.get_bias());
-      it_lab_ai::Tensor tmp_tensor = it_lab_ai::Tensor(
-          it_lab_ai::Shape({tensor.get_shape()[1], tensor.get_shape()[0]}),
-          it_lab_ai::Type::kFloat);
-      // kernel is always transposed ?
-      for (size_t h = 0; h < tensor.get_shape()[0]; h++) {
-        for (size_t w = 0; w < tensor.get_shape()[1]; w++) {
-          tmp_tensor.set<float>(std::vector<size_t>({w, h}),
-                                tensor.get<float>({h, w}));
-        }
-      }
-      //
-      tensor = tmp_tensor;
       auto fc_layer = std::make_shared<it_lab_ai::FCLayer>(tensor, tmp_bias);
       fc_layer->setName(it_lab_ai::kFullyConnected);
       layers.push_back(fc_layer);

app/Graph/graph_build.cpp

@@ -1,4 +1,4 @@
-#include <algorithm>
+#include <algorithm>
 #include <numeric>
 #include <unordered_map>
 
@@ -62,29 +62,28 @@ std::vector<int> get_input_shape_from_json(const std::string& json_path) {
       }
     }
   }
-
-  throw std::runtime_error("Could not determine input shape from JSON");
+  return {28};
 }
 
 std::vector<float> process_model_output(const std::vector<float>& output,
                                         const std::string& model_name) {
   bool is_yolo = (model_name.find("yolo") != std::string::npos);
 
   if (!is_yolo) {
-    // Äëÿ íå-YOLO ìîäåëåé èñïîëüçóåì ñòàíäàðòíûé softmax
+    // Для не-YOLO моделей используем стандартный softmax
     return softmax<float>(output);
   }
 
-  // Äëÿ YOLO ìîäåëåé àíàëèçèðóåì âûõîäíûå äàííûå
+  // Для YOLO моделей анализируем выходные данные
   float sum_val = std::accumulate(output.begin(), output.end(), 0.0f);
 
-  // Åñëè ñóììà áëèçêà ê 1, âåðîÿòíîñòè óæå íîðìàëèçîâàíû
+  // Если сумма близка к 1, вероятности уже нормализованы
   if (std::abs(sum_val - 1.0f) < 0.01f) {
     std::cout << "YOLO output already normalized, using as-is" << std::endl;
     return output;
   }
 
-  // Èíà÷å ïðèìåíÿåì softmax
+  // Иначе применяем softmax
   std::cout << "Applying softmax to YOLO output" << std::endl;
   return softmax<float>(output);
 }
@@ -104,15 +103,15 @@ it_lab_ai::Tensor prepare_image(const cv::Mat& image,
   cv::Mat processed_image;
   cv::Size target_size(width, height);
 
-  bool is_yolo_model =
-      (model_name.find("yolo") != std::string::npos || model_name.find("Google"));
+  bool is_yolo_model = (model_name.find("yolo") != std::string::npos ||
+                        model_name.find("Google"));
 
   if (image.rows == height && image.cols == width) {
     processed_image = image.clone();
     std::cout << "Image already at target size - no resize needed" << std::endl;
   } else {
     if (is_yolo_model) {
-      // Äëÿ YOLO: ðåñàéç ñ ñîõðàíåíèåì ñîîòíîøåíèÿ ñòîðîí
+      // Для YOLO: ресайз с сохранением соотношения сторон
       double scale = std::min(static_cast<double>(width) / image.cols,
                               static_cast<double>(height) / image.rows);
       int new_width = static_cast<int>(image.cols * scale);
@@ -145,11 +144,11 @@ it_lab_ai::Tensor prepare_image(const cv::Mat& image,
   processed_image.convertTo(float_image, CV_32FC3);
 
   if (is_yolo_model) {
-    // Äëÿ YOLO: ïðîñòàÿ íîðìàëèçàöèÿ 0-1
+    // Для YOLO: простая нормализация 0-1
     float_image /= 255.0;
     std::cout << "YOLO normalization: 0-1 range" << std::endl;
   } else {
-    // ImageNet íîðìàëèçàöèÿ äëÿ äðóãèõ ìîäåëåé
+    // ImageNet нормализация для других моделей
     float_image /= 255.0;
 
     if (channels == 3) {
@@ -192,6 +191,23 @@ it_lab_ai::Tensor prepare_image(const cv::Mat& image,
   return it_lab_ai::make_tensor(data, shape);
 }
 
+it_lab_ai::Tensor prepare_mnist_image(const cv::Mat& image) {
+  cv::Mat gray_image;
+  cv::cvtColor(image, gray_image, cv::COLOR_BGR2GRAY);
+  std::vector<cv::Mat> channels;
+  cv::split(image, channels);
+
+  std::vector<float> res(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);
+    }
+  }
+
+  Shape sh({1, 1, 28, 28});
+  return it_lab_ai::make_tensor(res, sh);
+}
+
 int main(int argc, char* argv[]) {
   std::string model_name = "alexnet_mnist";
   bool parallel = false;
@@ -207,20 +223,15 @@ int main(int argc, char* argv[]) {
   std::string json_path = model_paths[model_name];
 
   std::vector<int> input_shape;
-  try {
-    input_shape = get_input_shape_from_json(json_path);
-    std::cout << "Input shape: [";
-    for (size_t i = 0; i < input_shape.size(); ++i) {
-      std::cout << input_shape[i];
-      if (i < input_shape.size() - 1) std::cout << ", ";
-    }
-    std::cout << "]" << std::endl;
-  } catch (const std::exception& e) {
-    std::cerr << "Error reading input shape: " << e.what() << std::endl;
-    return 1;
-  }
+  input_shape = get_input_shape_from_json(json_path);
 
-  std::string image_folder = IMAGENET_PATH;
+  std::string image_folder;
+  if (model_name == "alexnet_mnist") {
+    image_folder = IMAGE28_PATH;
+  }
+  else {
+    image_folder = IMAGENET_PATH;
+  }
   std::cout << "Using image folder: " << image_folder << std::endl;
 
   std::vector<std::string> image_paths;
@@ -254,33 +265,59 @@ int main(int argc, char* argv[]) {
       std::cout << "Original size: " << image.cols << "x" << image.rows
                 << ", channels: " << image.channels() << std::endl;
 
-      it_lab_ai::Tensor input = prepare_image(image, input_shape, model_name);
-
       if (model_name == "alexnet_mnist") {
+        // Специальная обработка для MNIST
+        it_lab_ai::Tensor input = prepare_mnist_image(image);
+
+        // Создаем выходной тензор (заглушка - форма не важна для
+        // build_graph_linear)
         it_lab_ai::Shape sh1({1, 5, 5, 3});
         std::vector<float> vec(75, 3);
         it_lab_ai::Tensor output = it_lab_ai::make_tensor(vec, sh1);
 
-        build_graph_linear(input, output, json_path, true, parallel);
+        build_graph_linear(input, output, true, parallel);
 
+        // Получаем реальные выходы (10 классов для MNIST)
         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) {
-            std::cout << "Image: " << image_path << " -> Class: " << i
-                      << std::endl;
-          }
+
+        // Выводим топ-3 предсказания для MNIST
+        int top_n = std::min(3, static_cast<int>(tmp_output.size()));
+        std::vector<int> indices(tmp_output.size());
+        std::iota(indices.begin(), indices.end(), 0);
+        std::partial_sort(
+            indices.begin(), indices.begin() + top_n, indices.end(),
+            [&](int a, int b) { return tmp_output[a] > tmp_output[b]; });
+
+        std::cout << "Top " << top_n << " predictions for MNIST:" << std::endl;
+        for (int i = 0; i < top_n; i++) {
+          int idx = indices[i];
+          std::cout << "  " << (i + 1) << ". Class " << idx << ": "
+                    << std::fixed << std::setprecision(6)
+                    << tmp_output[idx] * 100 << "%" << std::endl;
         }
+
+        // Итоговый результат
+        int max_class = indices[0];
+        float max_prob = tmp_output[max_class];
+        std::cout << "Image: " << fs::path(image_path).filename().string()
+                  << " -> Predicted digit: " << max_class
+                  << " (probability: " << std::fixed << std::setprecision(6)
+                  << max_prob * 100 << "%)" << std::endl;
+
       } else {
+        // Обычная обработка для других моделей
+        it_lab_ai::Tensor input = prepare_image(image, input_shape, model_name);
+
         size_t output_classes = 1000;
         it_lab_ai::Tensor output({1, output_classes}, it_lab_ai::Type::kFloat);
 
         build_graph(input, output, json_path, true, parallel);
 
-        // Èñïîëüçóåì óëó÷øåííóþ îáðàáîòêó âûõîäîâ
+        // Используем улучшенную обработку выходов
         std::vector<float> tmp_output =
             process_model_output(*output.as<float>(), model_name);
 
-        // Íàõîäèì òîï-5 êëàññîâ
+        // Находим топ-5 классов
         int top_n = std::min(5, static_cast<int>(tmp_output.size()));
         std::vector<int> indices(tmp_output.size());
         std::iota(indices.begin(), indices.end(), 0);
@@ -300,7 +337,7 @@ int main(int argc, char* argv[]) {
           std::cout << std::endl;
         }
 
-        // Èòîãîâûé ðåçóëüòàò
+        // Итоговый результат
         int max_class = indices[0];
         float max_prob = tmp_output[max_class];
         std::cout << "Image: " << fs::path(image_path).filename().string()

include/graph/graph.hpp

@@ -137,26 +137,27 @@ class Graph {
     for (size_t i = 0; i < traversal.size(); ++i) {
       int current_layer = traversal[i];
 
-      // Ïðîñòîé âûâîä
-      /*std::string layer_name = getLayerName(current_layer);
-      std::cout << "Processing layer #" << current_layer << " (" << layer_name
-                << ")" << std::endl;
-      if (!inten_.empty()) {
-        std::cout << "Input shape: ";
-        for (size_t d = 0; d < inten_[0].get_shape().dims(); ++d) {
-          std::cout << inten_[0].get_shape()[d] << " ";
-        }
-        std::cout << std::endl;
-      }
-      std::cout << "Layer #" << current_layer << " ("
-                << getLayerName(current_layer) << ") has "
-                << in_edges_[current_layer].size() << " input connections"
-                << std::endl;
-
-      for (int input_id : in_edges_[current_layer]) {
-        std::cout << "  - From layer #" << input_id << " ("
-                  << getLayerName(input_id) << ")" << std::endl;
-      }*/
+      //// Ïðîñòîé âûâîä
+      //std::string layer_name = getLayerName(current_layer);
+      //std::cout << "Processing layer #" << current_layer << " (" << layer_name
+      //          << ")" << std::endl;
+      //if (!inten_.empty()) {
+      //  std::cout << "Input shape: ";
+      //  for (size_t d = 0; d < inten_[0].get_shape().dims(); ++d) {
+      //    std::cout << inten_[0].get_shape()[d] << " ";
+      //  }
+      //  std::cout << std::endl;
+      //}
+
+      //std::cout << "Layer #" << current_layer << " ("
+      //          << getLayerName(current_layer) << ") has "
+      //          << in_edges_[current_layer].size() << " input connections"
+      //          << std::endl;
+
+      //for (int input_id : in_edges_[current_layer]) {
+      //  std::cout << "  - From layer #" << input_id << " ("
+      //            << getLayerName(input_id) << ")" << std::endl;
+      //}
 #ifdef ENABLE_STATISTIC_TIME
       auto start = std::chrono::high_resolution_clock::now();
 #endif