ONNX&YOLO Converter (#185)

* The parser has been tested on the resnest101e_Opset16.onnx,
GoogLeNet.onnx, and densenet121_Opset16.onnx models.
- The yolo11x-cls.pt model has been converted to the onnx format using
ultralytics.
- The parser for our first model has been fixed to use a single json
file style and a single code for reading and converting to a tensor.
* I removed the check for the equality of the bias to the last dimension
of the weights from the tensor implementation, as in the onnx and yolo
models, the bias is equal in size to the first array.
- Additionally, the weights and bias data are now stored more explicitly
in json, with each data item in its own fields "weights": and "bias":,
which helps prevent potential errors during conversion.
* I also think that we should provide a link to download each model, as
we won't be able to store them all in the repository. We should also
configure the "evaluate model" check in github to download the model
from the link and enable caching.

Author: Semyon1104

.github/workflows/ci.yml

@@ -203,7 +203,9 @@ jobs:
         sudo ldconfig
     - name: Generate model JSON
       run: |
-        cd app/AlexNet
+        cd docs && mkdir jsons
+        cd ..
+        cd app/Converters
         pip install -r requirements.txt
         python parser.py
         cd ../..

.gitignore

@@ -3,6 +3,6 @@ build
 build*
 3rdparty/tensorflow
 app/AccuracyImgNet/imgs
-docs/model_data_alexnet_1.json
+docs/
 docs/input
 docs/mnist

README.md

@@ -20,6 +20,14 @@ A lightweight C++ library for performing high-performance inference on MNIST han
 ### Neural network models
 You need to download [Alexnet-model.h5](https://github.com/moizahmed97/Convolutional-Neural-Net-Designer/blob/master/AlexNet-model.h5) to the folder *docs*
 
+Other models:</br>
+[GoogLeNet.onnx](https://huggingface.co/qualcomm/GoogLeNet/resolve/main/GoogLeNet.onnx)</br>
+[yolo11x-cls.pt](https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11x-cls.pt)</br>
+[resnest101e_Opset16.onnx](https://github.com/onnx/models/raw/refs/heads/main/Computer_Vision/resnest101e_Opset16_timm/resnest101e_Opset16.onnx?download=)</br>
+[densenet121_Opset16.onnx](https://github.com/onnx/models/raw/refs/heads/main/Computer_Vision/densenet121_Opset16_timm/densenet121_Opset16.onnx?download=)
+
+
+
 ## **How do I launch the inference?**
 * Make sure you install the project dependencies by running: *pip install -r requirements.txt*
 * You need to run the script *parser.py* that is located in app/AlexNet to read weights from a model *Alexnet-model.h5* and the json file with the weights will be stored in the *docs* folder.

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/AlexNet/parser.py

@@ -0,0 +1,9 @@
+add_executable(Reader_weights reader_weights_sample.cpp)
+add_executable(Reader_weights_onnx reader_weights_sample_onnx.cpp)
+target_link_libraries(Reader_weights PUBLIC perf_lib layers_lib reader_lib)
+target_link_libraries(Reader_weights_onnx 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")
+add_definitions(-DMODEL_PATH_DENSENET_ONNX="${CMAKE_SOURCE_DIR}/docs/jsons/densenet121_Opset16_onnx_model.json")
+add_definitions(-DMODEL_PATH_RESNET_ONNX="${CMAKE_SOURCE_DIR}/docs/jsons/resnest101e_Opset16_onnx_model.json")
+add_definitions(-DMODEL_PATH_YOLO11NET_ONNX="${CMAKE_SOURCE_DIR}/docs/jsons/yolo11x-cls_onnx_model.json")

app/AlexNet/requirements.txt

@@ -0,0 +1,75 @@
+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)
+        super().__init__(seed=seed, **kwargs)
+
+
+class CustomZeros(OriginalZeros):
+    def __init__(self, **kwargs):
+        kwargs.pop('dtype', None)
+        super().__init__(**kwargs)
+
+
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+MODEL_PATH = os.path.join(BASE_DIR, 'docs/models', 'AlexNet-model.h5')
+MODEL_DATA_PATH = os.path.join(BASE_DIR, 'docs/jsons', '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__
+    layer_config = layer.get_config()
+    weights = layer.get_weights()
+
+    layer_data = {
+        'index': len(layer_info),
+        'name': layer_name,
+        'type': layer_type,
+        'weights': [],
+        'bias': []
+    }
+
+    if isinstance(layer, tf.keras.layers.Conv2D):
+        layer_data['padding'] = layer_config.get('padding', None)
+        layer_activation = layer_config.get('activation', None)
+
+        if len(weights) > 0:
+            layer_data['weights'] = weights[0].tolist()
+        if len(weights) > 1:
+            layer_data['bias'] = weights[1].tolist()
+
+    elif isinstance(layer, tf.keras.layers.Dense):
+        if len(weights) > 0:
+            layer_data['weights'] = weights[0].tolist()
+        if len(weights) > 1:
+            layer_data['bias'] = weights[1].tolist()
+
+    else:
+        if weights:
+            layer_data['weights'] = [w.tolist() for w in weights]
+
+    layer_info.append(layer_data)
+
+    if isinstance(layer, (tf.keras.layers.Conv2D)) and layer_activation:
+        activation_layer = {
+            'index': len(layer_info),
+            'name': f"activation_{layer_name}",
+            'type': layer_activation,
+            'weights': [],
+            'bias': []
+        }
+        layer_info.append(activation_layer)
+
+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/CMakeLists.txt

@@ -0,0 +1,122 @@
+import json
+import onnx
+import os
+from onnx import TensorProto
+from onnx import helper, numpy_helper
+from ultralytics import YOLO
+
+def convert_pt_to_onnx(pt_model_path, onnx_model_path=None):
+    if onnx_model_path is None:
+        onnx_model_path = pt_model_path.replace('.pt', '.onnx')
+
+    model = YOLO(pt_model_path)
+    model.export(format="onnx", dynamic=False, simplify=True)
+
+    return onnx_model_path
+
+def onnx_to_json(model_path, output_json_path):
+    if model_path.endswith('.pt'):
+        model_path = convert_pt_to_onnx(model_path)
+
+    model = onnx.load(model_path)
+    onnx.checker.check_model(model)
+
+    initializers_dict = {
+        init.name: {
+            "data_type": init.data_type,
+            "dims": list(init.dims),
+            "values": numpy_helper.to_array(init).tolist()
+        }
+        for init in model.graph.initializer
+    }
+
+    layer_info = []
+    input_layer = {
+        "index": 0,
+        "name": "input_1",
+        "type": "InputLayer",
+        "weights": [],
+        "attributes": {}
+    }
+    layer_info.append(input_layer)
+
+    for node in model.graph.node:
+        layer_data = {
+            "index": len(layer_info),
+            "name": node.name.replace('/', '_'),
+            "type": node.op_type,
+            "attributes": {}
+        }
+
+        for attr in node.attribute:
+            attr_value = helper.get_attribute_value(attr)
+            if isinstance(attr_value, TensorProto):
+                attr_value = numpy_helper.to_array(attr_value).tolist()
+            elif 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)
+            layer_data["attributes"][attr.name] = attr_value
+
+            if attr.name == "pads":
+                layer_data["padding"] = "same" if any(p > 0 for p in attr_value) else "valid"
+            elif attr.name == "kernel_shape":
+                layer_data["kernel_size"] = attr_value
+            elif attr.name == "strides":
+                layer_data["strides"] = attr_value
+
+        node_init = []
+        for input_name in node.input:
+            if input_name in initializers_dict:
+                node_init.append(initializers_dict[input_name])
+
+        if len(node_init) == 1:
+            init = node_init[0]
+            if len(init["dims"]) == 0 or (len(init["dims"]) == 1 and init["dims"][0] == 1):
+                layer_data["value"] = init["values"] if len(init["dims"]) == 0 else init["values"][0]
+            else:
+                layer_data["weights"] = init["values"]
+        elif len(node_init) > 1:
+            weights = []
+            for init in node_init[:-1]:
+                if len(init["dims"]) > 0:
+                    weights.extend(init["values"]) if isinstance(init["values"][0], list) else weights.append(
+                        init["values"])
+
+            if weights:
+                layer_data["weights"] = weights
+
+            if len(node_init[-1]["dims"]) == 1:
+                layer_data["bias"] = node_init[-1]["values"]
+
+        layer_info.append(layer_data)
+
+    class CustomEncoder(json.JSONEncoder):
+        def default(self, obj):
+            if isinstance(obj, TensorProto):
+                return {
+                    "name": obj.name,
+                    "dims": list(obj.dims),
+                    "data_type": obj.data_type,
+                    "raw_data": obj.raw_data.hex() if obj.raw_data else None,
+                }
+            elif hasattr(obj, 'tolist'):
+                return obj.tolist()
+            elif str(type(obj)).endswith("RepeatedScalarContainer'>"):
+                return list(obj)
+            return super().default(obj)
+
+    with open(output_json_path, 'w') as f:
+        json.dump(layer_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', 'yolo11x-cls.pt')
+MODEL_DATA_PATH = os.path.join(BASE_DIR, 'docs\\jsons', 'yolo11x-cls_onnx_model.json')
+
+onnx_to_json(MODEL_PATH, MODEL_DATA_PATH)