deepdoctection 0.31__py3-none-any.whl → 0.33__py3-none-any.whl

deepdoctection/extern/tp/tpfrcnn/preproc.py

@@ -8,23 +8,27 @@
 This file is modified from
 <https://github.com/tensorpack/tensorpack/blob/1a79d595f7eda9dc9dc8428f4461680ed2222ab6/examples/FasterRCNN/data.py>
 """
+from __future__ import annotations
 
 from typing import Any, List, Optional, Tuple
 
 import numpy as np
-
-# pylint: disable=import-error
-from tensorpack.dataflow.imgaug import AugmentorList, ImageAugmentor
+from lazy_imports import try_import
 
 from ....datapoint.convert import box_to_point4, point4_to_box
-from ....utils.detection_types import ImageType, JsonDict
 from ....utils.error import MalformedData
 from ....utils.logger import log_once
+from ....utils.types import JsonDict, PixelValues
 from .common import filter_boxes_inside_shape, np_iou
 from .modeling.model_fpn import get_all_anchors_fpn
 from .utils.np_box_ops import area as np_area
 from .utils.np_box_ops import ioa as np_ioa
 
+# pylint: disable=import-error
+
+
+with try_import() as import_guard:
+    from tensorpack.dataflow.imgaug import AugmentorList, ImageAugmentor
 # pylint: enable=import-error
 
 
@@ -210,15 +214,15 @@ def get_multilevel_rpn_anchor_input(
 
 
 def get_anchor_labels(
-    anchors: ImageType,
-    gt_boxes: ImageType,
-    crowd_boxes: ImageType,
+    anchors: PixelValues,
+    gt_boxes: PixelValues,
+    crowd_boxes: PixelValues,
     batch_per_image: int,
     front_ground_ratio: float,
     positive_anchor_threshold: float,
     negative_anchor_threshold: float,
     crowd_overlap_threshold: float,
-) -> (ImageType, ImageType):
+) -> (PixelValues, PixelValues):
     """
     Label each anchor as fg/bg/ignore.
 

deepdoctection/extern/tp/tpfrcnn/utils/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# File: __init__.py
+
+# Copyright 2021 Dr. Janis Meyer. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Init file for code for Tensorpack utils
+"""

deepdoctection/extern/tp/tpfrcnn/utils/box_ops.py

@@ -15,8 +15,16 @@ and
 """
 
 # pylint: disable=import-error
-import tensorflow as tf
-from tensorpack.tfutils.scope_utils import under_name_scope
+
+from lazy_imports import try_import
+
+with try_import() as tf_import_guard:
+    import tensorflow as tf
+    from tensorpack.tfutils.scope_utils import under_name_scope
+
+if not tf_import_guard.is_successful():
+    from .....utils.mocks import under_name_scope
+
 
 # pylint: enable=import-error
 

deepdoctection/extern/tpdetect.py

@@ -18,63 +18,57 @@
 """
 TP Faster RCNN model as predictor for deepdoctection pipeline
 """
+from __future__ import annotations
 
 from abc import ABC
-from copy import copy
 from pathlib import Path
-from typing import Dict, List, Mapping, Optional, Sequence, Union
+from typing import Mapping, Optional, Sequence, Union
 
-from ..utils.detection_types import ImageType, Requirement
-from ..utils.file_utils import get_tensorflow_requirement, get_tensorpack_requirement, tensorpack_available
+from ..utils.file_utils import get_tensorflow_requirement, get_tensorpack_requirement
 from ..utils.metacfg import set_config_by_yaml
-from ..utils.settings import ObjectTypes, TypeOrStr, get_type
-from .base import DetectionResult, ObjectDetector, PredictorBase
-
-if tensorpack_available():
-    from .tp.tpcompat import TensorpackPredictor
-    from .tp.tpfrcnn.config.config import model_frcnn_config
-    from .tp.tpfrcnn.modeling.generalized_rcnn import ResNetFPNModel
-    from .tp.tpfrcnn.predict import tp_predict_image
+from ..utils.settings import DefaultType, ObjectTypes, TypeOrStr, get_type
+from ..utils.types import PathLikeOrStr, PixelValues, Requirement
+from .base import DetectionResult, ModelCategories, ObjectDetector
+from .tp.tpcompat import TensorpackPredictor
+from .tp.tpfrcnn.config.config import model_frcnn_config
+from .tp.tpfrcnn.modeling.generalized_rcnn import ResNetFPNModel
+from .tp.tpfrcnn.predict import tp_predict_image
 
 
 class TPFrcnnDetectorMixin(ObjectDetector, ABC):
     """Base class for TP FRCNN detector. This class only implements the basic wrapper functions"""
 
-    def __init__(self, categories: Mapping[str, TypeOrStr], filter_categories: Optional[Sequence[TypeOrStr]] = None):
-        self.categories = copy(categories)  # type: ignore
+    def __init__(self, categories: Mapping[int, TypeOrStr], filter_categories: Optional[Sequence[TypeOrStr]] = None):
+        categories = {k: get_type(v) for k, v in categories.items()}
+        categories.update({0: get_type("background")})
+        self.categories = ModelCategories(categories)
         if filter_categories:
-            filter_categories = [get_type(cat) for cat in filter_categories]
-        self.filter_categories = filter_categories
-        self._tp_categories = self._map_to_tp_categories(categories)
+            self.categories.filter_categories = tuple(get_type(cat) for cat in filter_categories)
 
-    def _map_category_names(self, detection_results: List[DetectionResult]) -> List[DetectionResult]:
+    def _map_category_names(self, detection_results: list[DetectionResult]) -> list[DetectionResult]:
         """
         Populating category names to detection results
 
         :param detection_results: list of detection results
         :return: List of detection results with attribute class_name populated
         """
-        filtered_detection_result: List[DetectionResult] = []
+        filtered_detection_result: list[DetectionResult] = []
         for result in detection_results:
-            result.class_name = self._tp_categories[str(result.class_id)]
-            if self.filter_categories:
-                if result.class_name not in self.filter_categories:
-                    filtered_detection_result.append(result)
-            else:
+            result.class_name = self.categories.categories.get(
+                result.class_id if result.class_id else -1, DefaultType.DEFAULT_TYPE
+            )
+            if result.class_name != DefaultType.DEFAULT_TYPE:
                 filtered_detection_result.append(result)
         return filtered_detection_result
 
     @staticmethod
-    def _map_to_tp_categories(categories: Mapping[str, TypeOrStr]) -> Dict[str, ObjectTypes]:
-        categories = {str(key): get_type(categories[val]) for key, val in enumerate(categories, 1)}
-        categories["0"] = get_type("background")
-        return categories  # type: ignore
-
-    @staticmethod
-    def get_name(path_weights: str, architecture: str) -> str:
+    def get_name(path_weights: PathLikeOrStr, architecture: str) -> str:
         """Returns the name of the model"""
         return f"Tensorpack_{architecture}" + "_".join(Path(path_weights).parts[-2:])
 
+    def get_category_names(self) -> tuple[ObjectTypes, ...]:
+        return self.categories.get_categories(as_dict=False)
+
 
 class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
     """
@@ -99,10 +93,10 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
 
     def __init__(
         self,
-        path_yaml: str,
-        path_weights: str,
-        categories: Mapping[str, TypeOrStr],
-        config_overwrite: Optional[List[str]] = None,
+        path_yaml: PathLikeOrStr,
+        path_weights: PathLikeOrStr,
+        categories: Mapping[int, TypeOrStr],
+        config_overwrite: Optional[list[str]] = None,
         ignore_mismatch: bool = False,
         filter_categories: Optional[Sequence[TypeOrStr]] = None,
     ):
@@ -127,24 +121,19 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
         :param filter_categories: The model might return objects that are not supposed to be predicted and that should
                                   be filtered. Pass a list of category names that must not be returned
         """
-        self.path_yaml = path_yaml
-
-        self.categories = copy(categories)  # type: ignore
+        self.path_yaml = Path(path_yaml)
         self.config_overwrite = config_overwrite
-        if filter_categories:
-            filter_categories = [get_type(cat) for cat in filter_categories]
-        self.filter_categories = filter_categories
-        model = TPFrcnnDetector.get_wrapped_model(path_yaml, self.categories, config_overwrite)
+
+        model = TPFrcnnDetector.get_wrapped_model(path_yaml, categories, config_overwrite)
         TensorpackPredictor.__init__(self, model, path_weights, ignore_mismatch)
         TPFrcnnDetectorMixin.__init__(self, categories, filter_categories)
 
         self.name = self.get_name(path_weights, self._model.cfg.TAG)
         self.model_id = self.get_model_id()
-        assert self._number_gpus > 0, "Model only support inference with GPU"
 
     @staticmethod
     def get_wrapped_model(
-        path_yaml: str, categories: Mapping[str, ObjectTypes], config_overwrite: Union[List[str], None]
+        path_yaml: PathLikeOrStr, categories: Mapping[int, TypeOrStr], config_overwrite: Union[list[str], None]
     ) -> ResNetFPNModel:
         """
         Calls all necessary methods to build TP ResNetFPNModel
@@ -166,7 +155,7 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
         model_frcnn_config(config=hyper_param_config, categories=categories, print_summary=False)
         return ResNetFPNModel(config=hyper_param_config)
 
-    def predict(self, np_img: ImageType) -> List[DetectionResult]:
+    def predict(self, np_img: PixelValues) -> list[DetectionResult]:
         """
         Prediction per image.
 
@@ -183,15 +172,18 @@ class TPFrcnnDetector(TensorpackPredictor, TPFrcnnDetectorMixin):
         return self._map_category_names(detection_results)
 
     @classmethod
-    def get_requirements(cls) -> List[Requirement]:
+    def get_requirements(cls) -> list[Requirement]:
         return [get_tensorflow_requirement(), get_tensorpack_requirement()]
 
-    def clone(self) -> PredictorBase:
+    def clone(self) -> TPFrcnnDetector:
         return self.__class__(
-            self.path_yaml,
-            self.path_weights,
-            self.categories,
-            self.config_overwrite,
-            self.ignore_mismatch,
-            self.filter_categories,
+            path_yaml=self.path_yaml,
+            path_weights=self.path_weights,
+            categories=dict(self.categories.get_categories()),
+            config_overwrite=self.config_overwrite,
+            ignore_mismatch=self.ignore_mismatch,
+            filter_categories=self.categories.filter_categories,
         )
+
+    def clear_model(self) -> None:
+        self.tp_predictor = None

deepdoctection/mapper/__init__.py

@@ -20,9 +20,11 @@ Contains everything that is related to transformation between datapoints
 """
 from typing import Callable
 
-from ..utils.file_utils import pytorch_available, transformers_available
 from .cats import *
 from .cocostruct import *
+from .d2struct import *
+from .hfstruct import *
+from .laylmstruct import *
 from .maputils import *
 from .match import *
 from .misc import *
@@ -32,12 +34,5 @@ from .pubstruct import *
 from .tpstruct import *
 from .xfundstruct import *
 
-if pytorch_available() and transformers_available():
-    from .hfstruct import *
-    from .laylmstruct import *
-
-if pytorch_available():
-    from .d2struct import *
-
 # Mapper
 Mapper = Callable[[Image], Optional[Image]]

deepdoctection/mapper/cats.py

@@ -21,19 +21,19 @@ builder method of a dataset.
 """
 
 from collections import defaultdict
-from typing import Any, Dict, List, Literal, Mapping, Optional, Sequence, Tuple, Union
+from typing import Any, Literal, Mapping, Optional, Sequence, Union
 
-from ..datapoint.annotation import CategoryAnnotation, ContainerAnnotation, ImageAnnotation, SummaryAnnotation
+from ..datapoint.annotation import DEFAULT_CATEGORY_ID, CategoryAnnotation, ContainerAnnotation, ImageAnnotation
 from ..datapoint.image import Image
-from ..utils.settings import ObjectTypes, TypeOrStr, get_type
+from ..utils.settings import ObjectTypes, SummaryType, TypeOrStr, get_type
 from .maputils import LabelSummarizer, curry
 
 
 @curry
 def cat_to_sub_cat(
     dp: Image,
-    categories_dict_names_as_key: Dict[TypeOrStr, str],
-    cat_to_sub_cat_dict: Optional[Dict[TypeOrStr, TypeOrStr]] = None,
+    categories_dict_names_as_key: dict[TypeOrStr, int],
+    cat_to_sub_cat_dict: Optional[dict[TypeOrStr, TypeOrStr]] = None,
 ) -> Image:
     """
     Replace some category with its affiliated sub category of CategoryAnnotations. Suppose your category name is `foo`
@@ -49,13 +49,12 @@ def cat_to_sub_cat(
     if cat_to_sub_cat_dict is None:
         return dp
     cat_to_sub_cat_dict_obj_type = {get_type(key): get_type(value) for key, value in cat_to_sub_cat_dict.items()}
-    categories_dict = categories_dict_names_as_key
     for ann in dp.get_annotation_iter(category_names=list(cat_to_sub_cat_dict_obj_type.keys())):
         sub_cat_type = cat_to_sub_cat_dict_obj_type[get_type(ann.category_name)]
         sub_cat = ann.get_sub_category(sub_cat_type)
         if sub_cat:
             ann.category_name = sub_cat.category_name
-            ann.category_id = categories_dict[ann.category_name]
+            ann.category_id = categories_dict_names_as_key[ann.category_name]
 
     return dp
 
@@ -63,7 +62,7 @@ def cat_to_sub_cat(
 @curry
 def re_assign_cat_ids(
     dp: Image,
-    categories_dict_name_as_key: Optional[Dict[TypeOrStr, str]] = None,
+    categories_dict_name_as_key: Optional[dict[TypeOrStr, int]] = None,
     cat_to_sub_cat_mapping: Optional[Mapping[ObjectTypes, Any]] = None,
 ) -> Image:
     """
@@ -89,7 +88,7 @@ def re_assign_cat_ids(
     :return: Image
     """
 
-    anns_to_remove: List[ImageAnnotation] = []
+    anns_to_remove: list[ImageAnnotation] = []
     for ann in dp.get_annotation_iter():
         if categories_dict_name_as_key is not None:
             if ann.category_name in categories_dict_name_as_key:
@@ -103,7 +102,7 @@ def re_assign_cat_ids(
                 for key in sub_cat_keys_to_sub_cat_values:
                     sub_cat_values_dict = sub_cat_keys_to_sub_cat_values[key]
                     sub_category = ann.get_sub_category(key)
-                    sub_category.category_id = sub_cat_values_dict.get(sub_category.category_name, "")
+                    sub_category.category_id = sub_cat_values_dict.get(sub_category.category_name, DEFAULT_CATEGORY_ID)
 
     for ann in anns_to_remove:
         dp.remove(ann)
@@ -113,7 +112,7 @@ def re_assign_cat_ids(
 
 @curry
 def filter_cat(
-    dp: Image, categories_as_list_filtered: List[TypeOrStr], categories_as_list_unfiltered: List[TypeOrStr]
+    dp: Image, categories_as_list_filtered: list[TypeOrStr], categories_as_list_unfiltered: list[TypeOrStr]
 ) -> Image:
     """
     Filters category annotations based on the on a list of categories to be kept and a list of all possible
@@ -132,7 +131,7 @@ def filter_cat(
     remove_cats_mapper = remove_cats(category_names=cats_to_remove_list)  # pylint: disable=E1120  # 259
     dp = remove_cats_mapper(dp)
 
-    categories_dict_name_as_key = {v: str(k) for k, v in enumerate(categories_as_list_filtered, 1)}
+    categories_dict_name_as_key = {v: k for k, v in enumerate(categories_as_list_filtered, 1)}
     re_assign_cat_ids_mapper = re_assign_cat_ids(  # pylint: disable=E1120
         categories_dict_name_as_key=categories_dict_name_as_key
     )
@@ -160,13 +159,13 @@ def filter_summary(
     :return: Image or None
     """
     for key, values in sub_cat_to_sub_cat_names_or_ids.items():
-        if mode == "name" and dp.summary:
+        if mode == "name":
             if dp.summary.get_sub_category(get_type(key)).category_name in values:
                 return dp
-        elif mode == "value" and dp.summary:
+        elif mode == "value":
             if dp.summary.get_sub_category(get_type(key)).value in values:  # type: ignore
                 return dp
-        elif dp.summary:
+        else:
             if dp.summary.get_sub_category(get_type(key)).category_id in values:
                 return dp
     return None
@@ -179,7 +178,7 @@ def image_to_cat_id(
     sub_categories: Optional[Union[Mapping[TypeOrStr, TypeOrStr], Mapping[TypeOrStr, Sequence[TypeOrStr]]]] = None,
     summary_sub_category_names: Optional[Union[TypeOrStr, Sequence[TypeOrStr]]] = None,
     id_name_or_value: Literal["id", "name", "value"] = "id",
-) -> Tuple[Dict[TypeOrStr, Union[List[int], List[int]]], str]:
+) -> tuple[dict[TypeOrStr, list[int]], str]:
     """
     Extracts all category_ids, sub category information or summary sub category information with given names into a
     defaultdict. This mapping is useful when running evaluation with e.g. an accuracy metric.
@@ -199,7 +198,7 @@ def image_to_cat_id(
 
         will return
 
-            ({'foo':['1', '1'], 'bak':[ '2'], 'baz':['3']}, image_id)
+            ({'foo':[1,1], 'bak':[2], 'baz':[3]}, image_id)
 
 
     **Example 2:**
@@ -213,7 +212,7 @@ def image_to_cat_id(
 
         will return
 
-            ({'foo_sub_1':['5', '6']}, image_id)
+            ({'foo_sub_1':[5,6]}, image_id)
 
 
 
@@ -238,7 +237,7 @@ def image_to_cat_id(
     if not summary_sub_category_names:
         summary_sub_category_names = []
 
-    tmp_sub_category_names: Dict[str, Sequence[str]] = {}
+    tmp_sub_category_names: dict[str, Sequence[str]] = {}
 
     if sub_categories is not None:
         for key, val in sub_categories.items():
@@ -252,13 +251,13 @@ def image_to_cat_id(
     if category_names or sub_categories:
         for ann in dp.get_annotation_iter():
             if ann.category_name in category_names:
-                cat_container[ann.category_name].append(int(ann.category_id))
+                cat_container[ann.category_name].append(ann.category_id)
             if ann.category_name in tmp_sub_category_names:
                 for sub_cat_name in tmp_sub_category_names[ann.category_name]:
                     sub_cat = ann.get_sub_category(get_type(sub_cat_name))
                     if sub_cat is not None:
                         if id_name_or_value == "id":
-                            cat_container[sub_cat_name].append(int(sub_cat.category_id))
+                            cat_container[sub_cat_name].append(sub_cat.category_id)
                         if id_name_or_value == "name":
                             cat_container[sub_cat_name].append(sub_cat.category_name)  # type: ignore
                         if id_name_or_value == "value":
@@ -269,11 +268,11 @@ def image_to_cat_id(
                                 )
                             cat_container[sub_cat_name].append(sub_cat.value)  # type: ignore
 
-    if dp.summary is not None and summary_sub_category_names:
+    if summary_sub_category_names:
         for sub_cat_name in summary_sub_category_names:
             sub_cat = dp.summary.get_sub_category(get_type(sub_cat_name))
             if id_name_or_value == "id":
-                cat_container[sub_cat_name].append(int(sub_cat.category_id))
+                cat_container[sub_cat_name].append(sub_cat.category_id)
             if id_name_or_value == "name":
                 cat_container[sub_cat_name].append(sub_cat.category_name)  # type: ignore
             if id_name_or_value == "value":
@@ -344,15 +343,14 @@ def remove_cats(
         dp.remove(ann)
 
     if summary_sub_categories is not None:
-        if dp.summary is not None:
-            for sub_cat in summary_sub_categories:
-                dp.summary.remove_sub_category(get_type(sub_cat))
+        for sub_cat in summary_sub_categories:
+            dp.summary.remove_sub_category(get_type(sub_cat))
 
     return dp
 
 
 @curry
-def add_summary(dp: Image, categories: Mapping[str, ObjectTypes]) -> Image:
+def add_summary(dp: Image, categories: Mapping[int, ObjectTypes]) -> Image:
     """
     Adding a summary with the number of categories in an image.
 
@@ -366,10 +364,10 @@ def add_summary(dp: Image, categories: Mapping[str, ObjectTypes]) -> Image:
     for ann in anns:
         summarizer.dump(ann.category_id)
     summary_dict = summarizer.get_summary()
-    summary = SummaryAnnotation()
+    summary = CategoryAnnotation(category_name=SummaryType.SUMMARY)
     for cat_id, val in summary_dict.items():
         summary.dump_sub_category(
-            categories[cat_id], CategoryAnnotation(category_name=categories[cat_id], category_id=str(val))
+            categories[cat_id], CategoryAnnotation(category_name=categories[cat_id], category_id=val)
         )
     dp.summary = summary
     return dp

deepdoctection/mapper/cocostruct.py

@@ -20,21 +20,21 @@ Module for mapping annotations in coco style structure
 """
 
 import os
-from typing import Dict, List, Mapping, Optional, Tuple
+from typing import Mapping, Optional
 
 from ..datapoint.annotation import CategoryAnnotation, ImageAnnotation
 from ..datapoint.box import BoundingBox
 from ..datapoint.image import Image
-from ..utils.detection_types import JsonDict
 from ..utils.fs import load_image_from_file
 from ..utils.settings import ObjectTypes
+from ..utils.types import CocoDatapointDict, JsonDict
 from .maputils import MappingContextManager, curry, maybe_get_fake_score
 
 
 @curry
 def coco_to_image(
-    dp: JsonDict,
-    categories: Dict[str, str],
+    dp: CocoDatapointDict,
+    categories: dict[int, ObjectTypes],
     load_image: bool,
     filter_empty_image: bool,
     fake_score: bool,
@@ -88,7 +88,7 @@ def coco_to_image(
             bbox = BoundingBox(absolute_coords=True, ulx=x_1, uly=y_1, height=h, width=w)
 
             annotation = ImageAnnotation(
-                category_name=categories[str(ann["category_id"])],
+                category_name=categories[ann["category_id"]],
                 bounding_box=bbox,
                 category_id=ann["category_id"],
                 score=maybe_get_fake_score(fake_score),
@@ -98,8 +98,8 @@ def coco_to_image(
 
             if coarse_sub_cat_name and coarse_mapping:
                 sub_cat = CategoryAnnotation(
-                    category_name=categories[str(coarse_mapping[ann["category_id"]])],
-                    category_id=str(coarse_mapping[ann["category_id"]]),
+                    category_name=categories[coarse_mapping[ann["category_id"]]],
+                    category_id=coarse_mapping[ann["category_id"]],
                 )
                 annotation.dump_sub_category(coarse_sub_cat_name, sub_cat)
 
@@ -109,7 +109,7 @@ def coco_to_image(
     return image
 
 
-def image_to_coco(dp: Image) -> Tuple[JsonDict, List[JsonDict]]:
+def image_to_coco(dp: Image) -> tuple[JsonDict, list[JsonDict]]:
     """
     Converting an image back into the coco format. As images and anns are separated it will return a dict with the
     image information and one for its annotations.
@@ -122,7 +122,7 @@ def image_to_coco(dp: Image) -> Tuple[JsonDict, List[JsonDict]]:
         raise TypeError(f"datapoints must be of type Image, is of type {type(dp)}")
 
     img: JsonDict = {}
-    anns: List[JsonDict] = []
+    anns: list[JsonDict] = []
 
     img["id"] = int("".join([s for s in dp.image_id if s.isdigit()]))
     img["width"] = dp.width
@@ -133,7 +133,7 @@ def image_to_coco(dp: Image) -> Tuple[JsonDict, List[JsonDict]]:
         ann: JsonDict = {
             "id": int("".join([s for s in img_ann.annotation_id if s.isdigit()])),
             "image_id": img["id"],
-            "category_id": int(img_ann.category_id),
+            "category_id": img_ann.category_id,
         }
         if img_ann.score:
             ann["score"] = img_ann.score