add DGL architecture

models/public/gcn/accuracy-check.yml

@@ -0,0 +1,27 @@
+evaluations:
+  - name: gcn
+    module: custom_evaluators.dgl_evaluator.DGLEvaluator
+    module_config:
+      launchers:
+        - framework: dgl
+          model: C:\Users\Atikin\Desktop\Programming\open_model_zoo\tools\model_tools\src\omz_tools\public\gcn\gcn_model.pt
+
+      datasets:
+        - name: tmp
+          reader: graph(dgl)_reader
+          data_source: C:\Users\Atikin\Desktop\Programming\data_for_dl_benchmark\default_graph.bin
+          annotation_conversion:
+            converter: dgl
+            graph_path: C:\Users\Atikin\Desktop\Programming\data_for_dl_benchmark\data.bin
+
+          metrics:
+            - type: clip_accuracy
+              presenter: print_vector
+              reference:
+                clip_accuracy: 0.565
+                video_accuracy: 0.565283
+                mean: 0.565141
+      # data_source: C:\Users\Atikin\Desktop\Programming\data_for_dl_benchmark\default_graph.bin
+      # metrics:
+      # - type: accuracy
+

models/public/gcn/model.yml

@@ -0,0 +1,21 @@
+description: >-
+  Tmp
+task_type: node_classification
+files:
+  - name: gcn_model.pt
+    size: 94635
+    source: https://raw.githubusercontent.com/itlab-vision/itlab-vision-dl-benchmark-models/main/dgl/models/classification/GCN/gcn_model.pt
+    checksum: abceacb966cf92ce225e6b7e9b29b1a165e6283f0a780a1617344405d5661bd74ff4e3f7c6d7d0c14fbb44f486d24c2f
+  - name: GCN.py
+    size: 736
+    source: https://raw.githubusercontent.com/itlab-vision/itlab-vision-dl-benchmark-models/main/dgl/models/classification/GCN/GCN.py
+    checksum: a8cf92d876d5c4f495c8fc9c0354a1c337e60038c4c35b11959d5e56105c2f85d60378a41ba2436c7176dd9e708f761c
+model_optimizer_args:
+  - --input_shape=[1,3,227,227]
+  - --input=data
+  - --mean_values=data[104.0,117.0,123.0]
+  - --output=prob
+  - --input_model=$dl_dir/gcn_model.pt
+  - --model_class=$dl_dir/GCN.py
+framework: dgl_pytorch
+license: https://raw.githubusercontent.com/itlab-vision/itlab-vision-dl-benchmark-models/main/LICENSE

tools/accuracy_checker/accuracy_checker/annotation_converters/__init__.py

@@ -19,6 +19,7 @@
 from .market1501 import Market1501Converter
 from .veri776 import VeRi776Converter
 from .mars import MARSConverter
+from .dgl import DGLConverter
 from .pascal_voc import PascalVOCDetectionConverter, SYGDetectionConverter
 from .sample_converter import SampleConverter
 from .wider import WiderFormatConverter
@@ -149,6 +150,7 @@
     'SYGDetectionConverter',
     'WiderFormatConverter',
     'MARSConverter',
+    'DGLConverter',
     'DetectionOpenCVStorageFormatConverter',
     'LFWConverter',
     'FaceRecognitionBinary',

tools/accuracy_checker/accuracy_checker/annotation_converters/dgl.py

@@ -0,0 +1,27 @@
+import re
+
+from ._reid_common import check_dirs, read_directory
+from .format_converter import GraphFileBasedAnnotationConverter, ConverterReturn
+from ..representation import ClassificationAnnotation
+from pathlib import Path
+import dgl
+
+MARS_IMAGE_PATTERN = re.compile(r'([\d]+)C(\d)')
+
+
+class DGLConverter(GraphFileBasedAnnotationConverter):
+    __provider__ = 'dgl'
+    annotation_types = (ClassificationAnnotation, )
+
+    def convert(self, check_content=False, **kwargs):
+        print('run convert')
+        graph = dgl.data.utils.load_graphs(Path(self.graph_path).__str__())
+        g = graph[0][0]
+
+        labels = g.ndata["label"]
+
+        annotation = [
+            ClassificationAnnotation(label=labels)
+        ]
+
+        return ConverterReturn(annotation, {'labels': labels}, None)

tools/accuracy_checker/accuracy_checker/annotation_converters/format_converter.py

@@ -145,6 +145,22 @@ def convert(self, check_content=False, **kwargs):
         pass
 
 
+class GraphFileBasedAnnotationConverter(BaseFormatConverter):
+    @classmethod
+    def parameters(cls):
+        parameters = super().parameters()
+        parameters.update({
+            'graph_path': PathField(is_directory=False, description="Path to graph data.")
+        })
+        return parameters
+
+    def configure(self):
+        self.graph_path = self.get_value_from_config('graph_path')
+
+    def convert(self, check_content=False, **kwargs):
+        pass
+
+
 def verify_label_map(label_map):
     valid_label_map = {}
     for class_id, class_name in label_map.items():

tools/accuracy_checker/accuracy_checker/data_readers/__init__.py

@@ -53,6 +53,7 @@
     RawpyReader
 )
 from .text_readers import JSONReader
+from .dgl_graph_reader import DGLGraphReader
 
 __all__ = [
     'BaseReader',
@@ -92,6 +93,7 @@
     'LMDBReader',
     'KaldiARKReader',
     'JSONReader',
+    'DGLGraphReader'
 
     'create_reader',
     'REQUIRES_ANNOTATIONS',

tools/accuracy_checker/accuracy_checker/data_readers/dgl_graph_reader.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+from ..config import StringField, ConfigError
+from .data_reader import BaseReader
+from ..utils import get_path, read_json
+import dgl
+
+
+class DGLGraphReader(BaseReader):
+    __provider__ = 'graph(dgl)_reader'
+
+    def configure(self):
+        if not self.data_source:
+            if not self._postpone_data_source:
+                raise ConfigError('data_source parameter is required to create "{}" '
+                                  'data reader and read data'.format(self.__provider__))
+        else:
+            self.data_source = get_path(self.data_source, is_directory=False)
+
+    def read(self, data_id):
+        data_path = self.data_source / data_id if self.data_source is not None else data_id
+        print('read data')
+
+        graph = dgl.data.utils.load_graphs(Path(self.graph_path).__str__())
+        g = graph[0][0]
+
+        return g

tools/accuracy_checker/accuracy_checker/evaluators/custom_evaluators/dgl_evaluator.py

@@ -0,0 +1,38 @@
+from .base_custom_evaluator import BaseCustomEvaluator
+from .base_models import BaseCascadeModel, create_model, create_encoder
+
+class DGLEvaluator(BaseCustomEvaluator):
+    def __init__(self, dataset_config, launcher, model, orig_config):
+        super().__init__(dataset_config, launcher, orig_config)
+        print('create evaluator')
+        self.model = model
+        # if hasattr(self.model.decoder, 'adapter'):
+        #     self.adapter_type = self.model.decoder.adapter.__provider__
+
+    @classmethod
+    def from_configs(cls, config, delayed_model_loading=False, orig_config=None):
+        dataset_config, launcher, _ = cls.get_dataset_and_launcher_info(config)
+        model = DGLGraphModel(
+            config.get('network_info', {}), launcher, config.get('_models', []), config.get('_model_is_blob'),
+            delayed_model_loading
+        )
+        return cls(dataset_config, launcher, model, orig_config)
+
+    def _process(self, output_callback, calculate_metrics, progress_reporter, metric_config, csv_file):
+        pass
+
+class DGLGraphModel(BaseCascadeModel):
+    def __init__(self, network_info, launcher, models_args, is_blob, delayed_model_loading=False):
+        super().__init__(network_info, launcher)
+
+    def predict(self, identifiers, input_data, encoder_callback=None):
+        pass
+
+    def reset(self):
+        pass
+
+    def save_encoder_predictions(self):
+        pass
+
+    def _add_raw_encoder_predictions(self, encoder_prediction):
+        pass

tools/accuracy_checker/accuracy_checker/launcher/__init__.py

@@ -91,6 +91,13 @@
         'paddle_paddle', "PaddlePaddle isn't installed. Please, install it before using. \n{}".format(import_error.msg)
     )
 
+try:
+    from .dgl_launchar import DGLLauncher
+except ImportError as import_error:
+    DGLLauncher = unsupported_launcher(
+        'dgl', "DGL isn't installed. Please, install it before using. \n{}".format(import_error.msg)
+    )
+
 from .pytorch_launcher import PyTorchLauncher
 
 __all__ = [
@@ -107,5 +114,6 @@
     'PyTorchLauncher',
     'PaddlePaddleLauncher',
     'DummyLauncher',
-    'InputFeeder'
+    'InputFeeder',
+    'DGLLauncher'
 ]

tools/accuracy_checker/accuracy_checker/launcher/dgl_launchar.py

@@ -0,0 +1,53 @@
+import os
+from collections import OrderedDict
+
+from ..config import NumberField, StringField, BoolField
+from ..config import PathField, StringField, NumberField, BoolField, ConfigError
+from .launcher import Launcher
+
+import numpy as np
+
+class DGLLauncher(Launcher):
+    __provider__ = 'dgl'
+
+    def __init__(self, config_entry: dict, *args, **kwargs):
+        super().__init__(config_entry, *args, **kwargs)
+        try:
+            import dgl  # pylint: disable=C0415
+            self._dgl = dgl
+        except ImportError as import_error:
+            raise ValueError(
+                "DGL isn't installed. Please, install it before using. \n{}".format(
+                    import_error.msg
+                )
+            )
+
+        # self.validate_config(config_entry)
+
+        # self._device = self.get_value_from_config("device")
+        # self._vm_executor = self.get_value_from_config("vm")
+        # self._batch = self.get_value_from_config("batch")
+
+        # self._get_device()
+
+        # self._generate_inputs()
+
+        # self._module = self._load_module(config_entry["model"])
+
+        # self._generate_outputs()
+
+    @classmethod
+    def parameters(cls):
+        """Добавляем доп параметры для запуска
+        """
+        parameters = super().parameters()
+        parameters.update({
+            'model': PathField(description="Path to model.", file_or_directory=True)
+        })
+        return parameters
+
+    def release(self):
+        """
+        Releases launcher.
+        """
+        pass

tools/model_tools/src/omz_tools/_common.py

@@ -38,6 +38,7 @@
     'onnx': None,
     'pytorch': 'pytorch_to_onnx.py',
     'tf': None,
+    'dgl_pytorch': 'pytorch_to_onnx.py',
 }
 KNOWN_PRECISIONS = {
     'FP16', 'FP16-INT1', 'FP16-INT8',
@@ -74,6 +75,7 @@
     'time_series',
     'token_recognition',
     'background_matting',
+    'node_classification',
 }