add parser onnx and change converters

Author: Semyon1104

app/AlexNet/CMakeLists.txt

@@ -1,5 +1,5 @@
 add_subdirectory(ReaderImage)
 add_subdirectory(Accuracy)
-add_subdirectory(AlexNet)
+add_subdirectory(Converters)
 add_subdirectory(AccuracyImgNet)
 add_subdirectory(Graph)

app/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_executable(Reader_weights reader_weights_sample.cpp)
+
+target_link_libraries(Reader_weights PUBLIC perf_lib layers_lib reader_lib)
+
+add_definitions(-DMODEL_PATH_H5="${CMAKE_SOURCE_DIR}/docs/jsons/model_data_alexnet_1.json")
+add_definitions(-DMODEL_PATH_GOOGLENET_ONNX="${CMAKE_SOURCE_DIR}/docs/jsons/googlenet_onnx_model.json")

app/Converters/CMakeLists.txt

@@ -0,0 +1,69 @@
+import json
+import os
+
+import tensorflow as tf
+from tensorflow.keras.initializers import GlorotUniform as OriginalGlorotUniform, Zeros as OriginalZeros
+from tensorflow.keras.models import load_model
+
+class CustomGlorotUniform(OriginalGlorotUniform):
+    def __init__(self, seed=None, **kwargs):
+        kwargs.pop('dtype', None)  # Remove the unexpected dtype keyword if present
+        super().__init__(seed=seed, **kwargs)
+
+class CustomZeros(OriginalZeros):
+    def __init__(self, **kwargs):
+        kwargs.pop('dtype', None)  # Remove the unexpected dtype keyword if present
+        super().__init__(**kwargs)
+
+# Пути к модели и JSON файлу
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+MODEL_PATH = os.path.join(BASE_DIR, 'docs', 'AlexNet-model.h5')
+MODEL_DATA_PATH = os.path.join(BASE_DIR, 'docs', 'model_data_alexnet_1.json')
+
+# Загрузка модели
+model = load_model(MODEL_PATH, custom_objects={'GlorotUniform': CustomGlorotUniform, 'Zeros': CustomZeros})
+
+# Получение весов модели и информации о порядке слоев
+layer_info = []
+for index, layer in enumerate(model.layers):
+    layer_name = layer.name
+    layer_type = type(layer).__name__  # Тип слоя (например, Conv2D, Dense, Activation и т.д.)
+    layer_config = layer.get_config()
+
+    # Извлечение параметров слоя
+    layer_padding = None
+    layer_activation = None
+
+    if isinstance(layer, tf.keras.layers.Conv2D):
+        layer_padding = layer_config.get('padding', None)  # Считываем padding у Conv2D
+        layer_activation = layer_config.get('activation', None)  # Получаем функцию активации
+
+    # Сохранение информации о слое: его тип, имя, padding и веса
+    layer_data = {
+        'index': len(layer_info),  # Порядковый номер слоя
+        'name': layer_name,
+        'type': layer_type
+    }
+
+    if layer_padding is not None:
+        layer_data['padding'] = layer_padding
+
+    layer_data['weights'] = [w.tolist() for w in layer.get_weights()]
+
+    layer_info.append(layer_data)
+
+    # Если активация встроена в слой, добавляем её как отдельный слой
+    if layer_activation and not isinstance(layer, tf.keras.layers.Activation):
+        activation_layer = {
+            'index': len(layer_info),
+            'name': f"activation_{layer_name}",
+            'type': layer_activation,
+            'weights': []
+        }
+        layer_info.append(activation_layer)
+
+# Сохранение данных в JSON файл
+with open(MODEL_DATA_PATH, 'w') as f:
+    json.dump(layer_info, f, indent=2)
+
+print(f"Model data saved to {MODEL_DATA_PATH}")

app/Converters/parser.py

@@ -0,0 +1,114 @@
+import json
+import onnx
+import os
+from onnx import helper, numpy_helper
+
+
+def onnx_to_json(model_path, output_json_path):
+    # Загрузка модели
+    model = onnx.load(model_path)
+
+    # Проверка валидности модели
+    onnx.checker.check_model(model)
+
+    # Создаем словарь для хранения всей информации
+    model_info = {
+        "model_metadata": {
+            "ir_version": model.ir_version,
+            "opset_version": model.opset_import[0].version,
+            "producer_name": model.producer_name,
+            "producer_version": model.producer_version
+        },
+        "graph": {
+            "name": model.graph.name,
+            "inputs": [],
+            "outputs": [],
+            "nodes": [],
+            "initializers": []
+        }
+    }
+
+    # Обработка входных тензоров
+    for input in model.graph.input:
+        tensor_type = input.type.tensor_type
+        model_info["graph"]["inputs"].append({
+            "name": input.name,
+            "elem_type": tensor_type.elem_type,
+            "shape": [dim.dim_value if dim.HasField("dim_value") else dim.dim_param
+                      for dim in tensor_type.shape.dim]
+        })
+
+    # Обработка выходных тензоров
+    for output in model.graph.output:
+        tensor_type = output.type.tensor_type
+        model_info["graph"]["outputs"].append({
+            "name": output.name,
+            "elem_type": tensor_type.elem_type,
+            "shape": [dim.dim_value if dim.HasField("dim_value") else dim.dim_param
+                      for dim in tensor_type.shape.dim]
+        })
+
+    # Обработка узлов (операций)
+    for node in model.graph.node:
+        node_info = {
+            "name": node.name,
+            "op_type": node.op_type,
+            "inputs": list(node.input),  # Convert to list
+            "outputs": list(node.output),  # Convert to list
+            "attributes": []
+        }
+
+        for attr in node.attribute:
+            attr_value = helper.get_attribute_value(attr)
+            # Handle different attribute types
+            if isinstance(attr_value, bytes):
+                attr_value = attr_value.decode('utf-8', errors='ignore')
+            elif hasattr(attr_value, 'tolist'):
+                attr_value = attr_value.tolist()
+            elif str(type(attr_value)).endswith("RepeatedScalarContainer'>"):
+                attr_value = list(attr_value)
+
+            node_info["attributes"].append({
+                "name": attr.name,
+                "value": attr_value
+            })
+
+        model_info["graph"]["nodes"].append(node_info)
+
+    # Обработка инициализаторов (весов)
+    for initializer in model.graph.initializer:
+        # Получаем значения весов в виде списка
+        weights = numpy_helper.to_array(initializer).tolist()
+
+        model_info["graph"]["initializers"].append({
+            "name": initializer.name,
+            "data_type": initializer.data_type,
+            "dims": list(initializer.dims),
+            "values": weights  # Внимание: для больших моделей это может занять много памяти!
+        })
+
+    # Обработка метаданных
+    if model.metadata_props:
+        model_info["metadata"] = {}
+        for prop in model.metadata_props:
+            model_info["metadata"][prop.key] = prop.value
+
+    # Custom JSON encoder to handle remaining non-serializable objects
+    class CustomEncoder(json.JSONEncoder):
+        def default(self, obj):
+            if hasattr(obj, 'tolist'):
+                return obj.tolist()
+            elif str(type(obj)).endswith("RepeatedScalarContainer'>"):
+                return list(obj)
+            return super().default(obj)
+
+    # Сохранение в JSON файл
+    with open(output_json_path, 'w') as f:
+        json.dump(model_info, f, indent=2, cls=CustomEncoder)
+
+    print(f"Модель успешно сохранена в {output_json_path}")
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+MODEL_PATH = os.path.join(BASE_DIR, 'docs\\models', 'GoogLeNet.onnx')
+MODEL_DATA_PATH = os.path.join(BASE_DIR, 'docs\\jsons', 'googlenet_onnx_model.json')
+onnx_to_json(MODEL_PATH, MODEL_DATA_PATH)

app/Converters/parser_onnx.py

@@ -0,0 +1,28 @@
+#include <iostream>
+
+#include "Weights_Reader/reader_weights.hpp"
+
+int main() {
+  std::string json_file = MODEL_PATH_H5;
+  json model_data = read_json(json_file);
+
+  for (const auto& layer_data : model_data) {
+    int layer_index = layer_data["index"];
+    std::string layer_name = layer_data["name"];
+    std::string layer_type = layer_data["type"];
+
+    std::cout << "Layer " << layer_index << " (" << layer_type << ", "
+              << layer_name << "):" << std::endl;
+
+    try {
+      Tensor tensor =
+          create_tensor_from_json(layer_data["weights"], Type::kFloat);
+      // std::cout << tensor << std::endl;
+    } catch (const std::exception& e) {
+      std::cerr << "Error processing layer " << layer_name << ": " << e.what()
+                << std::endl;
+    }
+  }
+
+  return 0;
+}

app/Converters/reader_weights_sample.cpp

@@ -0,0 +1,2 @@
+tensorflow==2.19.0
+onnx==1.14.1

app/Converters/requirements.txt

@@ -70,5 +70,6 @@ file(DOWNLOAD
 )
 
 add_definitions(-DIMAGE1_PATH="${CMAKE_SOURCE_DIR}/docs/input/")
-add_definitions(-DMODEL_PATH="${CMAKE_SOURCE_DIR}/docs/model_data_alexnet_1.json")
+add_definitions(-DMODEL_PATH_H5="${CMAKE_SOURCE_DIR}/docs/jsons/model_data_alexnet_1.json")
+add_definitions(-DMODEL_PATH_GOOGLENET_ONNX="${CMAKE_SOURCE_DIR}/docs/jsons/googlenet_onnx_model.json")
 add_definitions(-DMNIST_PATH="${CMAKE_SOURCE_DIR}/docs/mnist/mnist/test")

app/Graph/CMakeLists.txt

@@ -25,7 +25,7 @@ void build_graph(Tensor& input, Tensor& output, bool comments,
   ImplType impl2 = parallel ? kSTL : kDefault;
   std::vector<std::shared_ptr<Layer>> layers;
 
-  std::string json_file = MODEL_PATH;
+  std::string json_file = MODEL_PATH_H5;
   json model_data = read_json(json_file);
 
   if (comments) std::cout << "Loaded model data from JSON." << std::endl;