AC: get meta from converter (#2949)

Author: eaidova

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/action_recognition.py

@@ -101,17 +101,25 @@ def configure(self):
                 warnings.warn("image_subpath is provided. "
                               "Make sure that data_source is {}".format(self.data_dir / self.image_subdir))
 
-    def convert(self, check_content=False, progress_callback=None, progress_interval=100, **kwargs):
-        full_annotation = read_json(self.annotation_file, object_pairs_hook=OrderedDict)
-        data_ext, data_dir = self.get_ext_and_dir()
-        label_map = dict(enumerate(full_annotation['labels']))
+    def get_meta(self):
         if self.dataset_meta:
             dataset_meta = read_json(self.dataset_meta)
             if 'label_map' in dataset_meta:
                 label_map = dataset_meta['label_map']
                 label_map = verify_label_map(label_map)
-            elif 'labels' in dataset_meta:
+                return {'label_map': label_map}
+            if 'labels' in dataset_meta:
                 label_map = dict(enumerate(dataset_meta['labels']))
+                return {'label_map': label_map}
+        full_annotation = read_json(self.annotation_file, object_pairs_hook=OrderedDict)
+        label_map = dict(enumerate(full_annotation['labels']))
+        return {'label_map': label_map}
+
+    def convert(self, check_content=False, progress_callback=None, progress_interval=100, **kwargs):
+        full_annotation = read_json(self.annotation_file, object_pairs_hook=OrderedDict)
+        meta = self.get_meta()
+        label_map = meta['label_map']
+        data_ext, data_dir = self.get_ext_and_dir()
         video_names, annotations = self.get_video_names_and_annotations(full_annotation['database'], self.subset)
         class_to_idx = {v: k for k, v in label_map.items()}
 
@@ -143,7 +151,7 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
 
             annotations.append(ClassificationAnnotation(identifier, clip['label']))
 
-        return ConverterReturn(annotations, {'label_map': label_map}, content_errors)
+        return ConverterReturn(annotations, meta, content_errors)
 
     def get_ext_and_dir(self):
         if self.two_stream_input:

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/ade20k_dataset_converter.py

@@ -56,9 +56,9 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
             if progress_callback and idx % progress_interval == 0:
                 progress_callback(idx * 100 / num_iterations)
             annotations.append(SegmentationAnnotation(identifier, annotation_path.name))
-        return ConverterReturn(annotations, self.read_meta(), content_errors)
+        return ConverterReturn(annotations, self.get_meta(), content_errors)
 
-    def read_meta(self):
+    def get_meta(self):
         categories_dist = DictReader(self.object_categories_file.open(), delimiter='\t')
         if self.num_classes:
             label_map = {int(category['Idx']): category['Name'] for category in categories_dist

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/amazon.py

@@ -162,6 +162,7 @@ def __next__(self):
 
         return source, target
 
+
 class AmazonProductData(BaseFormatConverter):
 
     __provider__ = 'amazon_product_data'

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/antispoofing.py

@@ -14,11 +14,12 @@
 limitations under the License.
 """
 
-from .format_converter import ConverterReturn, FileBasedAnnotationConverter
+from .format_converter import ConverterReturn, FileBasedAnnotationConverter, verify_label_map
 from ..representation import ClassificationAnnotation
 from ..utils import read_json, check_file_existence
 from ..config import PathField, NumberField
 
+
 class AntispoofingDatasetConverter(FileBasedAnnotationConverter):
     __provider__ = 'antispoofing'
     annotation_types = (ClassificationAnnotation, )
@@ -68,7 +69,7 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
         annotation_tuple = self.generate_annotations()
         annotations = []
         content_errors = None if not check_content else []
-        meta = self.generate_meta()
+        meta = self.get_meta()
         num_iterations = len(annotations)
 
         for i, (img_name, label, bbox) in enumerate(annotation_tuple):
@@ -85,11 +86,15 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
 
         return ConverterReturn(annotations, meta, content_errors)
 
-    def generate_meta(self):
+    def get_meta(self):
         if not self.meta:
             return {'label_map': {'real': 0, 'spoof': 1}}
         dataset_meta = read_json(self.meta)
         label_map = dataset_meta.get('label_map')
+        if label_map:
+            label_map = verify_label_map(label_map)
+        if not label_map and 'labels' in dataset_meta:
+            label_map = dict(enumerate(dataset_meta['labels']))
         dataset_meta['label_map'] = label_map or {'real': 0, 'spoof': 1}
         return dataset_meta
 

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/background_matting.py

@@ -83,9 +83,12 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
                 progress_callback(idx / num_iterations * 100)
 
         return ConverterReturn(
-            annotations, {'label_map': {'background': 0, 'foreground': list(range(1, 256))}}, content_errors
+            annotations, self.get_meta(), content_errors
         )
 
+    def get_meta(self):
+        return {'label_map': {'background': 0, 'foreground': list(range(1, 256))}}
+
 
 class VideoBackgroundMatting(BackgroundMattingConverter):
     __provider__ = 'video_background_matting'
@@ -125,5 +128,5 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
                 progress_callback(idx / num_iterations * 100)
 
         return ConverterReturn(
-            annotations, {'label_map': {'background': 0, 'foreground': list(range(1, 256))}}, content_errors
+            annotations, self.get_meta(), content_errors
         )

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/brats.py

@@ -30,6 +30,7 @@
 except ImportError as import_error:
     nib = UnsupportedPackage("nibabel", import_error.msg)
 
+
 class BratsConverter(DirectoryBasedAnnotationConverter):
     __provider__ = 'brats'
     annotation_types = (BrainTumorSegmentationAnnotation, )
@@ -125,9 +126,9 @@ def convert(self, check_content=False, **kwargs):
 
                 annotations.append(annotation)
 
-        return ConverterReturn(annotations, self._get_meta(), content_check_errors)
+        return ConverterReturn(annotations, self.get_meta(), content_check_errors)
 
-    def _get_meta(self):
+    def get_meta(self):
         if not self.labels_file:
             return None
         return {'label_map': dict(enumerate(read_txt(self.labels_file)))}
@@ -222,9 +223,9 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
             if progress_callback is not None and i % progress_interval == 0:
                 progress_callback(i / num_iterations * 100)
 
-        return ConverterReturn(annotations, self._get_meta(), check_content_errors)
+        return ConverterReturn(annotations, self.get_meta(), check_content_errors)
 
-    def _get_meta(self):
+    def get_meta(self):
         if not self.labels_file:
             return None
         return {'label_map': dict(enumerate(read_txt(self.labels_file)))}

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/camvid.py

@@ -76,15 +76,17 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
             annotations.append(SegmentationAnnotation(identifier, gt_file))
             if progress_callback is not None and line_id % progress_interval == 0:
                 progress_callback(line_id * 100 / num_iterations)
+        return ConverterReturn(annotations, self.get_meta(), content_errors)
+
+    def get_meta(self):
         meta = self.meta
         if self.dataset_meta:
             meta = read_json(self.dataset_meta)
             if 'label_map' in meta:
                 meta['label_map'] = verify_label_map(meta['label_map'])
             if 'labels' in meta and 'label_map' not in meta:
                 meta['label_map'] = dict(enumerate(meta['labels']))
-
-        return ConverterReturn(annotations, meta, content_errors)
+        return meta
 
 
 class CamVid32DatasetConverter(BaseFormatConverter):
@@ -169,12 +171,14 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
             if progress_callback and idx % progress_interval == 0:
                 progress_callback(idx * 100 / val_subset_size)
 
+        return ConverterReturn(annotations, self.get_meta(), content_errors)
+
+    def get_meta(self):
         meta = self.meta
         if self.dataset_meta:
             meta = read_json(self.dataset_meta)
             if 'label_map' in meta:
                 meta['label_map'] = verify_label_map(meta['label_map'])
             if 'labels' in meta and 'label_map' not in meta:
                 meta['label_map'] = dict(enumerate(meta['labels']))
-
-        return ConverterReturn(annotations, meta, content_errors)
+        return meta

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/cifar.py

@@ -204,3 +204,12 @@ def generate_meta(self, labels_offset, annotation):
             meta['background_label'] = 0
 
         return meta, labels, labels_id
+
+    def get_meta(self):
+        annotation_dict = read_pickle(self.data_batch_file, encoding='latin1')
+        labels_offset = 0 if not self.has_background else 1
+        # crete metadata for dataset. Provided additional information is task specific and can includes, for example
+        # label_map, information about background, used class color representation (for semantic segmentation task)
+        # If your dataset does not have additional meta, you can to not provide it.
+        meta, _, _ = self.generate_meta(labels_offset, annotation_dict)
+        return meta

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/cityscapes.py

@@ -123,9 +123,9 @@ def convert(self, check_content=False, progress_callback=None, progress_interval
             if progress_callback is not None and idx % progress_interval == 0:
                 progress_callback(idx / num_iterations * 100)
 
-        return ConverterReturn(annotations, self.generate_meta(), content_errors)
+        return ConverterReturn(annotations, self.get_meta(), content_errors)
 
-    def generate_meta(self):
+    def get_meta(self):
         if self.dataset_meta_file is not None:
             meta = read_json(self.dataset_meta_file)
             if 'label_map' in meta:

tools/accuracy_checker/openvino/tools/accuracy_checker/annotation_converters/coco_facial_landmarks.py

@@ -39,8 +39,8 @@ def configure(self):
         super().configure()
         self.images_dir = self.get_value_from_config('images_dir') or self.annotation_file.parent
 
-    @classmethod
-    def _collectImageIds(cls, data):
+    @staticmethod
+    def _collect_image_ids(data):
         result = {}
         for itm in data:
             img_name = itm["file_name"]
@@ -49,12 +49,11 @@ def _collectImageIds(cls, data):
 
         return result
 
-
     def convert(self, check_content=False, progress_callback=None, progress_interval=100, **kwargs):
         with open(self.annotation_file, encoding='UTF-8') as f:
             data = json.load(f)
         coco_ann = data["annotations"]
-        id2name = self._collectImageIds(data["images"])
+        id2name = self._collect_image_ids(data["images"])
         num_landmarks = 98
         annotations = []
         for ann_id, ann in enumerate(coco_ann[1:]):