deepdoctection 0.32__py3-none-any.whl → 0.34__py3-none-any.whl

deepdoctection/datasets/instances/xfund.py

@@ -37,8 +37,8 @@ from ...dataflow import CustomDataFromList, DataFlow, MapData
 from ...datasets.info import DatasetInfo
 from ...mapper.cats import cat_to_sub_cat, filter_cat
 from ...mapper.xfundstruct import xfund_to_image
-from ...utils.detection_types import JsonDict
 from ...utils.settings import BioTag, DatasetType, LayoutType, ObjectTypes, TokenClasses, TokenClassWithTag, WordType
+from ...utils.types import FunsdDict
 from ..base import _BuiltInDataset
 from ..dataflow_builder import DataFlowBaseBuilder
 from ..info import DatasetCategories
@@ -56,7 +56,7 @@ _LICENSE = (
 )
 _URL = "https://github.com/doc-analysis/XFUND/releases/tag/v1.0"
 _SPLITS: Mapping[str, str] = {"train": "train", "val": "val"}
-_TYPE = DatasetType.token_classification
+_TYPE = DatasetType.TOKEN_CLASSIFICATION
 _LOCATION = "xfund"
 _ANNOTATION_FILES: Mapping[str, Union[str, Sequence[str]]] = {
     "train": [
@@ -70,24 +70,23 @@ _ANNOTATION_FILES: Mapping[str, Union[str, Sequence[str]]] = {
     ],
     "val": ["de.val.json", "es.val.json", "fr.val.json", "it.val.json", "ja.val.json", "pt.val.json", "zh.val.json"],
 }
-_INIT_CATEGORIES = [LayoutType.word, LayoutType.text]
-_SUB_CATEGORIES: Mapping[ObjectTypes, Mapping[ObjectTypes, Sequence[ObjectTypes]]]
-_SUB_CATEGORIES = {
-    LayoutType.word: {
-        WordType.token_class: [TokenClasses.other, TokenClasses.question, TokenClasses.answer, TokenClasses.header],
-        WordType.tag: [BioTag.inside, BioTag.outside, BioTag.begin],
-        WordType.token_tag: [
-            TokenClassWithTag.b_answer,
-            TokenClassWithTag.b_header,
-            TokenClassWithTag.b_question,
-            TokenClassWithTag.i_answer,
-            TokenClassWithTag.i_header,
-            TokenClassWithTag.i_question,
-            BioTag.outside,
+_INIT_CATEGORIES: Sequence[ObjectTypes] = [LayoutType.WORD, LayoutType.TEXT]
+_SUB_CATEGORIES: Mapping[ObjectTypes, Mapping[ObjectTypes, Sequence[ObjectTypes]]] = {
+    LayoutType.WORD: {
+        WordType.TOKEN_CLASS: [TokenClasses.OTHER, TokenClasses.QUESTION, TokenClasses.ANSWER, TokenClasses.HEADER],
+        WordType.TAG: [BioTag.INSIDE, BioTag.OUTSIDE, BioTag.BEGIN],
+        WordType.TOKEN_TAG: [
+            TokenClassWithTag.B_ANSWER,
+            TokenClassWithTag.B_HEADER,
+            TokenClassWithTag.B_QUESTION,
+            TokenClassWithTag.I_ANSWER,
+            TokenClassWithTag.I_HEADER,
+            TokenClassWithTag.I_QUESTION,
+            BioTag.OUTSIDE,
         ],
     },
-    LayoutType.text: {
-        WordType.token_class: [TokenClasses.other, TokenClasses.question, TokenClasses.answer, TokenClasses.header]
+    LayoutType.TEXT: {
+        WordType.TOKEN_CLASS: [TokenClasses.OTHER, TokenClasses.QUESTION, TokenClasses.ANSWER, TokenClasses.HEADER]
     },
 }
 
@@ -168,7 +167,7 @@ class XfundBuilder(DataFlowBaseBuilder):
         df = CustomDataFromList(datapoints, max_datapoints=max_datapoints)
 
         # Map
-        def replace_filename(dp: JsonDict) -> JsonDict:
+        def replace_filename(dp: FunsdDict) -> FunsdDict:
             folder = "_".join(dp["id"].split("_", 2)[:2])
             dp["img"]["fname"] = os.path.join(self.get_workdir(), folder, dp["img"]["fname"])
             return dp
@@ -176,18 +175,40 @@ class XfundBuilder(DataFlowBaseBuilder):
         df = MapData(df, replace_filename)
         categories_name_as_key = self.categories.get_categories(init=True, name_as_key=True)
         token_class_names_mapping = {
-            "other": TokenClasses.other,
-            "question": TokenClasses.question,
-            "answer": TokenClasses.answer,
-            "header": TokenClasses.header,
+            "other": TokenClasses.OTHER,
+            "question": TokenClasses.QUESTION,
+            "answer": TokenClasses.ANSWER,
+            "header": TokenClasses.HEADER,
         }
-        ner_token_to_id_mapping = self.categories.get_sub_categories(
-            categories=LayoutType.word,
-            sub_categories={LayoutType.word: [WordType.token_tag, WordType.tag, WordType.token_class]},
-            keys=False,
-            values_as_dict=True,
-            name_as_key=True,
-        )
+        if LayoutType.WORD in self.categories.get_categories(filtered=True, name_as_key=True):
+            ner_token_to_id_mapping = self.categories.get_sub_categories(
+                categories=LayoutType.WORD,
+                sub_categories={LayoutType.WORD: [WordType.TOKEN_TAG, WordType.TAG, WordType.TOKEN_CLASS]},
+                keys=False,
+                values_as_dict=True,
+                name_as_key=True,
+            )
+        else:
+            ner_token_to_id_mapping = {
+                LayoutType.WORD: {
+                    WordType.TAG: {BioTag.BEGIN: 3, BioTag.INSIDE: 1, BioTag.OUTSIDE: 2},
+                    WordType.TOKEN_CLASS: {
+                        TokenClasses.ANSWER: 3,
+                        TokenClasses.HEADER: 4,
+                        TokenClasses.OTHER: 1,
+                        TokenClasses.QUESTION: 2,
+                    },
+                    WordType.TOKEN_TAG: {
+                        TokenClassWithTag.B_ANSWER: 1,
+                        TokenClassWithTag.B_HEADER: 2,
+                        TokenClassWithTag.B_QUESTION: 3,
+                        TokenClassWithTag.I_ANSWER: 4,
+                        TokenClassWithTag.I_HEADER: 5,
+                        TokenClassWithTag.I_QUESTION: 6,
+                        BioTag.OUTSIDE: 7,
+                    },
+                }
+            }
         df = MapData(
             df,
             xfund_to_image(

deepdoctection/datasets/save.py

@@ -20,20 +20,21 @@ Module for saving
 """
 
 import json
+import os
 from pathlib import Path
 from typing import Optional
 
 from ..dataflow import DataFlow, MapData, SerializerJsonlines
 from ..datapoint.convert import convert_b64_to_np_array
 from ..datapoint.image import Image
-from ..utils.detection_types import JsonDict, Pathlike
 from ..utils.fs import mkdir_p
+from ..utils.types import ImageDict, PathLikeOrStr
 from ..utils.viz import viz_handler
 
 
 def dataflow_to_json(
     df: DataFlow,
-    path: Pathlike,
+    path: PathLikeOrStr,
     single_files: bool = False,
     file_name: Optional[str] = None,
     max_datapoints: Optional[int] = None,
@@ -53,8 +54,7 @@ def dataflow_to_json(
     :param save_image_in_json: Will save the image to the JSON object
     :param highest_hierarchy_only: If True it will remove all image attributes of ImageAnnotations
     """
-    if isinstance(path, str):
-        path = Path(path)
+    path = Path(path)
     if single_files:
         mkdir_p(path)
     if not save_image_in_json:
@@ -68,8 +68,8 @@ def dataflow_to_json(
         df = MapData(df, _remove_hh)
     df = MapData(df, lambda dp: dp.as_dict())
 
-    def _path_to_str(dp: JsonDict) -> JsonDict:
-        dp["location"] = str(dp["location"])
+    def _path_to_str(dp: ImageDict) -> ImageDict:
+        dp["location"] = os.fspath(dp["location"])
         return dp
 
     df = MapData(df, _path_to_str)

deepdoctection/eval/accmetric.py

@@ -19,9 +19,8 @@
 Module for Accuracy metric
 """
 from collections import Counter
-from typing import Any
 from typing import Counter as TypeCounter
-from typing import Dict, List, Mapping, Optional, Sequence, Tuple, Union
+from typing import Mapping, Optional, Sequence, Union
 
 import numpy as np
 from numpy import float32, int32
@@ -32,10 +31,10 @@ from termcolor import colored
 from ..dataflow import DataFlow
 from ..datasets.info import DatasetCategories
 from ..mapper.cats import image_to_cat_id
-from ..utils.detection_types import JsonDict
 from ..utils.file_utils import Requirement
 from ..utils.logger import LoggingRecord, logger
 from ..utils.settings import ObjectTypes, TypeOrStr, get_type
+from ..utils.types import MetricResults
 from .base import MetricBase
 from .registry import metric_registry
 
@@ -54,7 +53,7 @@ __all__ = [
 
 def _mask_some_gt_and_pr_labels(
     np_label_gt: NDArray[int32], np_label_pr: NDArray[int32], masks: Sequence[int]
-) -> Tuple[NDArray[int32], NDArray[int32]]:
+) -> tuple[NDArray[int32], NDArray[int32]]:
     if len(np_label_gt) != len(masks):
         raise ValueError(f"length of label_gt ({len(np_label_gt)}) and masks ({len(masks)}) must be equal")
     np_masks = np.asarray(masks)
@@ -77,8 +76,8 @@ def accuracy(label_gt: Sequence[int], label_predictions: Sequence[int], masks: O
     Calculates the accuracy given predictions and labels. Ignores masked indices. Uses
     `sklearn.metrics.accuracy_score`
 
-    :param label_gt: List of ground truth labels
-    :param label_predictions: List of predictions. Must have the same length as label_gt
+    :param label_gt: list of ground truth labels
+    :param label_predictions: list of predictions. Must have the same length as label_gt
     :param masks: An optional list with masks to ignore some samples.
 
     :return: Accuracy score with only unmasked values to be considered
@@ -102,9 +101,9 @@ def confusion(
     """
     Calculates the accuracy matrix given the predictions and labels. Ignores masked indices.
 
-    :param label_gt: List of ground truth labels
-    :param label_predictions: List of predictions. Must have the same length as label_gt
-    :param masks: List with masks of same length as label_gt.
+    :param label_gt: list of ground truth labels
+    :param label_predictions: list of predictions. Must have the same length as label_gt
+    :param masks: list with masks of same length as label_gt.
 
     :return: numpy array
     """
@@ -127,9 +126,9 @@ def precision(
     Calculates the precision for a multi classification problem using a confusion matrix. The output will
     be the precision by category.
 
-    :param label_gt: List of ground truth labels
-    :param label_predictions: List of predictions. Must have the same length as label_gt
-    :param masks: List with masks of same length as label_gt.
+    :param label_gt: list of ground truth labels
+    :param label_predictions: list of predictions. Must have the same length as label_gt
+    :param masks: list with masks of same length as label_gt.
     :param micro: If True, it will calculate the micro average precision
     :return:  numpy array
     """
@@ -157,9 +156,9 @@ def recall(
     Calculates the recall for a multi classification problem using a confusion matrix. The output will
     be the recall by category.
 
-    :param label_gt: List of ground truth labels
-    :param label_predictions: List of predictions. Must have the same length as label_gt
-    :param masks: List with masks of same length as label_gt.
+    :param label_gt: list of ground truth labels
+    :param label_predictions: list of predictions. Must have the same length as label_gt
+    :param masks: list with masks of same length as label_gt.
     :param micro: If True, it will calculate the micro average recall
     :return:  numpy array
     """
@@ -188,9 +187,9 @@ def f1_score(
     Calculates the recall for a multi classification problem using a confusion matrix. The output will
     be the recall by category.
 
-    :param label_gt: List of ground truth labels
-    :param label_predictions: List of predictions. Must have the same length as label_gt
-    :param masks: List with masks of same length as label_gt.
+    :param label_gt: list of ground truth labels
+    :param label_predictions: list of predictions. Must have the same length as label_gt
+    :param masks: list with masks of same length as label_gt.
     :param micro: If True, it will calculate the micro average f1 score
     :param per_label: If True, it will return the f1 score per label, otherwise will return the mean of all f1's
     :return:  numpy array
@@ -217,7 +216,7 @@ class ClassificationMetric(MetricBase):
     @classmethod
     def dump(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> Tuple[Any, Any]:
+    ) -> tuple[dict[str, list[int]], dict[str, list[int]]]:
         dataflow_gt.reset_state()
         dataflow_predictions.reset_state()
 
@@ -225,8 +224,8 @@ class ClassificationMetric(MetricBase):
         if cls._cats is None and cls._sub_cats is None:
             cls._cats = categories.get_categories(as_dict=False, filtered=True)
         mapper_with_setting = cls.mapper(cls._cats, cls._sub_cats, cls._summary_sub_cats)
-        labels_gt: Dict[str, List[int]] = {}
-        labels_predictions: Dict[str, List[int]] = {}
+        labels_gt: dict[str, list[int]] = {}
+        labels_predictions: dict[str, list[int]] = {}
 
         # returned images of gt and predictions are likely not in the same order. We therefore first stream all data
         # into a dict and generate our result vectors thereafter.
@@ -253,7 +252,7 @@ class ClassificationMetric(MetricBase):
     @classmethod
     def get_distance(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> List[JsonDict]:
+    ) -> list[MetricResults]:
         labels_gt, labels_pr = cls.dump(dataflow_gt, dataflow_predictions, categories)
 
         results = []
@@ -290,7 +289,7 @@ class ClassificationMetric(MetricBase):
                  sub_category_names = {cat1: [sub_cat1, sub_cat2], cat2: sub_cat3}
 
 
-        :param category_names: List of category names
+        :param category_names: list of category names
         :param sub_category_names: Dict of categories and their sub categories that are supposed to be evaluated,
                                    e.g. {"FOO": ["bak","baz"]} will evaluate "bak" and "baz"
         :param summary_sub_category_names: string or list of summary sub categories
@@ -346,7 +345,7 @@ class ClassificationMetric(MetricBase):
             )
 
     @classmethod
-    def get_requirements(cls) -> List[Requirement]:
+    def get_requirements(cls) -> list[Requirement]:
         return []
 
     @property
@@ -395,7 +394,7 @@ class ConfusionMetric(ClassificationMetric):
     @classmethod
     def get_distance(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> List[JsonDict]:
+    ) -> list[MetricResults]:
         labels_gt, labels_pr = cls.dump(dataflow_gt, dataflow_predictions, categories)
 
         results = []
@@ -407,10 +406,10 @@ class ConfusionMetric(ClassificationMetric):
                     results.append(
                         {
                             "key": key.value if isinstance(key, ObjectTypes) else key,
-                            "category_id_gt": row_number,
+                            "category_id": row_number,
                             "category_id_pr": col_number,
                             "val": float(val),
-                            "num_samples_gt": number_labels[row_number],
+                            "num_samples": number_labels[row_number],
                         }
                     )
         cls._results = results
@@ -420,12 +419,12 @@ class ConfusionMetric(ClassificationMetric):
     def print_result(cls) -> None:
         data = {}
         for entry in cls._results:
-            if entry["category_id_gt"] not in data:
-                data[entry["category_id_gt"]] = [entry["category_id_gt"], entry["val"]]
+            if entry["category_id"] not in data:
+                data[entry["category_id"]] = [entry["category_id"], entry["val"]]
             else:
-                data[entry["category_id_gt"]].append(entry["val"])
+                data[entry["category_id"]].append(entry["val"])
 
-        header = ["predictions -> \n  ground truth |\n              v"] + list(data.keys())
+        header = ["predictions -> \n  ground truth |\n              v"] + list(list(str(element) for element in data))
         table = tabulate([data[k] for k, _ in enumerate(data, 1)], headers=header, tablefmt="pipe")
         logger.info("Confusion matrix: \n %s", colored(table, "cyan"))
 
@@ -442,7 +441,7 @@ class PrecisionMetric(ClassificationMetric):
     @classmethod
     def get_distance(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> List[JsonDict]:
+    ) -> list[MetricResults]:
         labels_gt, labels_pr = cls.dump(dataflow_gt, dataflow_predictions, categories)
 
         results = []
@@ -494,7 +493,7 @@ class PrecisionMetricMicro(ClassificationMetric):
     @classmethod
     def get_distance(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> List[JsonDict]:
+    ) -> list[MetricResults]:
         labels_gt, labels_pr = cls.dump(dataflow_gt, dataflow_predictions, categories)
 
         results = []

deepdoctection/eval/base.py

@@ -20,13 +20,13 @@ Module for the base class for evaluations and metrics
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, Callable, List, Optional, Tuple
+from typing import Any, Callable, Optional
 
 from ..dataflow import DataFlow
 from ..datasets.info import DatasetCategories
-from ..utils.detection_types import JsonDict
 from ..utils.error import DependencyError
 from ..utils.file_utils import Requirement
+from ..utils.types import MetricResults
 
 
 class MetricBase(ABC):
@@ -46,8 +46,7 @@ class MetricBase(ABC):
 
     name: str
     metric: Callable[[Any, Any], Optional[Any]]
-    mapper: Callable[[Any, Any], Optional[Any]]
-    _results: List[JsonDict]
+    _results: list[MetricResults]
 
     def __new__(cls, *args, **kwargs):  # type: ignore # pylint: disable=W0613
         requirements = cls.get_requirements()
@@ -63,7 +62,7 @@ class MetricBase(ABC):
 
     @classmethod
     @abstractmethod
-    def get_requirements(cls) -> List[Requirement]:
+    def get_requirements(cls) -> list[Requirement]:
         """
         Get a list of requirements for running the detector
         """
@@ -73,7 +72,7 @@ class MetricBase(ABC):
     @abstractmethod
     def get_distance(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> List[JsonDict]:
+    ) -> list[MetricResults]:
         """
         Takes of the ground truth processing strand as well as the prediction strand and generates the metric results.
 
@@ -87,7 +86,7 @@ class MetricBase(ABC):
     @abstractmethod
     def dump(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> Tuple[Any, Any]:
+    ) -> tuple[Any, Any]:
         """
         Dump the dataflow with ground truth annotations and predictions. Use it as auxiliary method and call it from
         `get_distance`.
@@ -99,7 +98,7 @@ class MetricBase(ABC):
         raise NotImplementedError()
 
     @classmethod
-    def result_list_to_dict(cls, results: List[JsonDict]) -> JsonDict:
+    def result_list_to_dict(cls, results: list[MetricResults]) -> MetricResults:
         """
         Converts the result from `get_distance` to a dict. It concatenates all keys of the inner dict and uses
         the metric result 'val' as value.
@@ -107,7 +106,7 @@ class MetricBase(ABC):
         :param results: List of dict as input
         :return: Dict with metric results.
         """
-        output: JsonDict = {}
+        output: MetricResults = {}
         for res in results:
             new_key = ""
             new_val = 0.0

deepdoctection/eval/cocometric.py

@@ -18,9 +18,10 @@
 """
 Module for metrics that require the COCOeval class.
 """
+from __future__ import annotations
 
 from copy import copy
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import numpy as np
 from lazy_imports import try_import
@@ -29,8 +30,8 @@ from ..dataflow import DataFlow
 from ..datasets.info import DatasetCategories
 from ..mapper.cats import re_assign_cat_ids
 from ..mapper.cocostruct import image_to_coco
-from ..utils.detection_types import JsonDict
 from ..utils.file_utils import Requirement, cocotools_available, get_cocotools_requirement
+from ..utils.types import JsonDict, MetricResults
 from .base import MetricBase
 from .registry import metric_registry
 
@@ -120,15 +121,15 @@ class CocoMetric(MetricBase):
 
     name = "mAP and mAR"
     metric = COCOeval if cocotools_available() else None
-    mapper = image_to_coco  # type: ignore
+    mapper = image_to_coco
     _f1_score = None
     _f1_iou = None
-    _params: Dict[str, Union[List[int], List[List[int]]]] = {}
+    _params: dict[str, Union[list[int], list[list[int]]]] = {}
 
     @classmethod
     def dump(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> Tuple["COCO", "COCO"]:
+    ) -> tuple[COCO, COCO]:
         cats = [{"id": int(k), "name": v} for k, v in categories.get_categories(as_dict=True, filtered=True).items()]
         imgs_gt, imgs_pr = [], []
         anns_gt, anns_pr = [], []
@@ -137,11 +138,11 @@ class CocoMetric(MetricBase):
         dataflow_predictions.reset_state()
 
         for dp_gt, dp_pred in zip(dataflow_gt, dataflow_predictions):
-            img_gt, ann_gt = cls.mapper(dp_gt)  # type: ignore
+            img_gt, ann_gt = cls.mapper(dp_gt)
             dp_pred = re_assign_cat_ids(categories.get_categories(as_dict=True, filtered=True, name_as_key=True))(
                 dp_pred
             )
-            img_pr, ann_pr = cls.mapper(dp_pred)  # type: ignore
+            img_pr, ann_pr = cls.mapper(dp_pred)
             imgs_gt.append(img_gt)
             imgs_pr.append(img_pr)
             anns_gt.extend(ann_gt)
@@ -162,7 +163,7 @@ class CocoMetric(MetricBase):
     @classmethod
     def get_distance(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> List[JsonDict]:
+    ) -> list[MetricResults]:
         coco_gt, coco_predictions = cls.dump(dataflow_gt, dataflow_predictions, categories)
 
         metric = cls.metric(coco_gt, coco_predictions, iouType="bbox")
@@ -192,7 +193,7 @@ class CocoMetric(MetricBase):
         return results
 
     @classmethod
-    def get_summary_default_parameters(cls) -> List[JsonDict]:
+    def get_summary_default_parameters(cls) -> list[JsonDict]:
         """
         Returns default parameters of evaluation results. May differ from other CocoMetric classes.
 
@@ -215,8 +216,8 @@ class CocoMetric(MetricBase):
     @classmethod
     def set_params(
         cls,
-        max_detections: Optional[List[int]] = None,
-        area_range: Optional[List[List[int]]] = None,
+        max_detections: Optional[list[int]] = None,
+        area_range: Optional[list[list[int]]] = None,
         f1_score: bool = False,
         f1_iou: float = 0.9,
     ) -> None:
@@ -239,5 +240,5 @@ class CocoMetric(MetricBase):
         cls._f1_iou = f1_iou
 
     @classmethod
-    def get_requirements(cls) -> List[Requirement]:
+    def get_requirements(cls) -> list[Requirement]:
         return [get_cocotools_requirement()]