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

deepdoctection/eval/eval.py

@@ -19,36 +19,35 @@
 """
 Module for `Evaluator`
 """
-
-__all__ = ["Evaluator"]
+from __future__ import annotations
 
 from copy import deepcopy
-from typing import Any, Dict, List, Literal, Mapping, Optional, Type, Union, overload
+from typing import Any, Generator, Literal, Mapping, Optional, Type, Union, overload
 
 import numpy as np
+from lazy_imports import try_import
 
 from ..dataflow import CacheData, DataFlow, DataFromList, MapData
 from ..datapoint.image import Image
 from ..datasets.base import DatasetBase
 from ..mapper.cats import filter_cat, remove_cats
+from ..mapper.d2struct import to_wandb_image
 from ..mapper.misc import maybe_load_image, maybe_remove_image, maybe_remove_image_from_category
-from ..pipe.base import LanguageModelPipelineComponent, PredictorPipelineComponent
+from ..pipe.base import PipelineComponent
 from ..pipe.common import PageParsingService
 from ..pipe.concurrency import MultiThreadPipelineComponent
 from ..pipe.doctectionpipe import DoctectionPipe
-from ..utils.detection_types import ImageType
-from ..utils.file_utils import detectron2_available, wandb_available
 from ..utils.logger import LoggingRecord, logger
 from ..utils.settings import DatasetType, LayoutType, TypeOrStr, get_type
+from ..utils.types import PixelValues
 from ..utils.viz import interactive_imshow
 from .base import MetricBase
 
-if wandb_available():
+with try_import() as wb_import_guard:
     import wandb  # pylint:disable=W0611
     from wandb import Artifact, Table
 
-if wandb_available() and detectron2_available():
-    from ..mapper.d2struct import to_wandb_image
+__all__ = ["Evaluator"]
 
 
 class Evaluator:
@@ -91,10 +90,10 @@ class Evaluator:
     def __init__(
         self,
         dataset: DatasetBase,
-        component_or_pipeline: Union[PredictorPipelineComponent, LanguageModelPipelineComponent, DoctectionPipe],
+        component_or_pipeline: Union[PipelineComponent, DoctectionPipe],
         metric: Union[Type[MetricBase], MetricBase],
         num_threads: int = 2,
-        run: Optional["wandb.sdk.wandb_run.Run"] = None,
+        run: Optional[wandb.sdk.wandb_run.Run] = None,
     ) -> None:
         """
         Evaluating a pipeline component on a dataset with a given metric.
@@ -109,14 +108,14 @@ class Evaluator:
         self.pipe: Optional[DoctectionPipe] = None
 
         # when passing a component, we will process prediction on num_threads
-        if isinstance(component_or_pipeline, (PredictorPipelineComponent, LanguageModelPipelineComponent)):
+        if isinstance(component_or_pipeline, PipelineComponent):
             logger.info(
                 LoggingRecord(
                     f"Building multi threading pipeline component to increase prediction throughput. "
                     f"Using {num_threads} threads"
                 )
             )
-            pipeline_components: List[Union[PredictorPipelineComponent, LanguageModelPipelineComponent]] = []
+            pipeline_components: list[PipelineComponent] = []
 
             for _ in range(num_threads - 1):
                 copy_pipe_component = component_or_pipeline.clone()
@@ -140,14 +139,14 @@ class Evaluator:
 
         self.wandb_table_agent: Optional[WandbTableAgent]
         if run is not None:
-            if self.dataset.dataset_info.type == DatasetType.object_detection:
+            if self.dataset.dataset_info.type == DatasetType.OBJECT_DETECTION:
                 self.wandb_table_agent = WandbTableAgent(
                     run,
                     self.dataset.dataset_info.name,
                     50,
                     self.dataset.dataflow.categories.get_categories(filtered=True),
                 )
-            elif self.dataset.dataset_info.type == DatasetType.token_classification:
+            elif self.dataset.dataset_info.type == DatasetType.TOKEN_CLASSIFICATION:
                 if hasattr(self.metric, "sub_cats"):
                     sub_cat_key, sub_cat_val_list = list(self.metric.sub_cats.items())[0]
                     sub_cat_val = sub_cat_val_list[0]
@@ -179,16 +178,16 @@ class Evaluator:
     @overload
     def run(
         self, output_as_dict: Literal[False] = False, **dataflow_build_kwargs: Union[str, int]
-    ) -> List[Dict[str, float]]:
+    ) -> list[dict[str, float]]:
         ...
 
     @overload
-    def run(self, output_as_dict: Literal[True], **dataflow_build_kwargs: Union[str, int]) -> Dict[str, float]:
+    def run(self, output_as_dict: Literal[True], **dataflow_build_kwargs: Union[str, int]) -> dict[str, float]:
         ...
 
     def run(
         self, output_as_dict: bool = False, **dataflow_build_kwargs: Union[str, int]
-    ) -> Union[List[Dict[str, float]], Dict[str, float]]:
+    ) -> Union[list[dict[str, float]], dict[str, float]]:
         """
         Start evaluation process and return the results.
 
@@ -247,11 +246,11 @@ class Evaluator:
         possible_cats_in_datapoint = self.dataset.dataflow.categories.get_categories(as_dict=False, filtered=True)
 
         # clean-up procedure depends on the dataset type
-        if self.dataset.dataset_info.type == DatasetType.object_detection:
+        if self.dataset.dataset_info.type == DatasetType.OBJECT_DETECTION:
             # we keep all image annotations that will not be generated through processing
-            anns_to_keep = {ann for ann in possible_cats_in_datapoint if ann not in meta_anns["image_annotations"]}
-            sub_cats_to_remove = meta_anns["sub_categories"]
-            relationships_to_remove = meta_anns["relationships"]
+            anns_to_keep = {ann for ann in possible_cats_in_datapoint if ann not in meta_anns.image_annotations}
+            sub_cats_to_remove = meta_anns.sub_categories
+            relationships_to_remove = meta_anns.relationships
             # removing annotations takes place in three steps: First we remove all image annotations. Then, with all
             # remaining image annotations we check, if the image attribute (with Image instance !) is not empty and
             # remove it as well, if necessary. In the last step we remove all sub categories and relationships, if
@@ -263,19 +262,19 @@ class Evaluator:
                 remove_cats(sub_categories=sub_cats_to_remove, relationships=relationships_to_remove),
             )
 
-        elif self.dataset.dataset_info.type == DatasetType.sequence_classification:
-            summary_sub_cats_to_remove = meta_anns["summaries"]
+        elif self.dataset.dataset_info.type == DatasetType.SEQUENCE_CLASSIFICATION:
+            summary_sub_cats_to_remove = meta_anns.summaries
             df_pr = MapData(df_pr, remove_cats(summary_sub_categories=summary_sub_cats_to_remove))
 
-        elif self.dataset.dataset_info.type == DatasetType.token_classification:
-            sub_cats_to_remove = meta_anns["sub_categories"]
+        elif self.dataset.dataset_info.type == DatasetType.TOKEN_CLASSIFICATION:
+            sub_cats_to_remove = meta_anns.sub_categories
             df_pr = MapData(df_pr, remove_cats(sub_categories=sub_cats_to_remove))
         else:
             raise NotImplementedError()
 
         return df_pr
 
-    def compare(self, interactive: bool = False, **kwargs: Union[str, int]) -> Optional[ImageType]:
+    def compare(self, interactive: bool = False, **kwargs: Union[str, int]) -> Generator[PixelValues, None, None]:
         """
         Visualize ground truth and prediction datapoint. Given a dataflow config it will run predictions per sample
         and concat the prediction image (with predicted bounding boxes) with ground truth image.
@@ -292,6 +291,8 @@ class Evaluator:
         show_layouts = kwargs.pop("show_layouts", True)
         show_table_structure = kwargs.pop("show_table_structure", True)
         show_words = kwargs.pop("show_words", False)
+        show_token_class = kwargs.pop("show_token_class", True)
+        ignore_default_token_class = kwargs.pop("ignore_default_token_class", False)
 
         df_gt = self.dataset.dataflow.build(**kwargs)
         df_pr = self.dataset.dataflow.build(**kwargs)
@@ -300,7 +301,7 @@ class Evaluator:
         df_pr = MapData(df_pr, deepcopy)
         df_pr = self._clean_up_predict_dataflow_annotations(df_pr)
 
-        page_parsing_component = PageParsingService(text_container=LayoutType.word)
+        page_parsing_component = PageParsingService(text_container=LayoutType.WORD)
         df_gt = page_parsing_component.predict_dataflow(df_gt)
 
         if self.pipe_component:
@@ -321,18 +322,21 @@ class Evaluator:
                 show_layouts=show_layouts,
                 show_table_structure=show_table_structure,
                 show_words=show_words,
+                show_token_class=show_token_class,
+                ignore_default_token_class=ignore_default_token_class,
             ), dp_pred.viz(
                 show_tables=show_tables,
                 show_layouts=show_layouts,
                 show_table_structure=show_table_structure,
                 show_words=show_words,
+                show_token_class=show_token_class,
+                ignore_default_token_class=ignore_default_token_class,
             )
             img_concat = np.concatenate((img_gt, img_pred), axis=1)
             if interactive:
                 interactive_imshow(img_concat)
             else:
-                return img_concat
-        return None
+                yield img_concat
 
 
 class WandbTableAgent:
@@ -350,11 +354,11 @@ class WandbTableAgent:
 
     def __init__(
         self,
-        wandb_run: "wandb.sdk.wandb_run.Run",
+        wandb_run: wandb.sdk.wandb_run.Run,
         dataset_name: str,
         num_samples: int,
-        categories: Mapping[str, TypeOrStr],
-        sub_categories: Optional[Mapping[str, TypeOrStr]] = None,
+        categories: Mapping[int, TypeOrStr],
+        sub_categories: Optional[Mapping[int, TypeOrStr]] = None,
         cat_to_sub_cat: Optional[Mapping[TypeOrStr, TypeOrStr]] = None,
     ):
         """
@@ -381,8 +385,8 @@ class WandbTableAgent:
         self._counter = 0
 
         # Table logging utils
-        self._table_cols: List[str] = ["file_name", "image"]
-        self._table_rows: List[Any] = []
+        self._table_cols: list[str] = ["file_name", "image"]
+        self._table_rows: list[Any] = []
         self._table_ref = None
 
     def dump(self, dp: Image) -> Image:
@@ -409,7 +413,7 @@ class WandbTableAgent:
         self._table_rows = []
         self._counter = 0
 
-    def _build_table(self) -> "Table":
+    def _build_table(self) -> Table:
         """
         Builds wandb.Table object for logging evaluation
 
@@ -435,4 +439,4 @@ class WandbTableAgent:
         eval_art.add(self._build_table(), self.dataset_name)
         self._run.use_artifact(eval_art)
         eval_art.wait()
-        self._table_ref = eval_art.get(self.dataset_name).data  # type:ignore
+        self._table_ref = eval_art.get(self.dataset_name).data  # type: ignore

deepdoctection/eval/tedsmetric.py

@@ -18,30 +18,34 @@ Tree distance similarity metric taken from <https://github.com/ibm-aur-nlp/PubTa
 
 import statistics
 from collections import defaultdict, deque
-from typing import Any, List, Optional, Tuple
+from typing import Any, Callable, Optional
+
+from lazy_imports import try_import
 
 from ..dataflow import DataFlow, DataFromList, MapData, MultiThreadMapData
+from ..datapoint.image import Image
 from ..datapoint.view import Page
 from ..datasets.base import DatasetCategories
-from ..utils.detection_types import JsonDict
-from ..utils.file_utils import (
-    Requirement,
-    apted_available,
-    distance_available,
-    get_apted_requirement,
-    get_distance_requirement,
-    get_lxml_requirement,
-    lxml_available,
-)
+from ..utils.file_utils import Requirement, get_apted_requirement, get_distance_requirement, get_lxml_requirement
 from ..utils.logger import LoggingRecord, logger
 from ..utils.settings import LayoutType
+from ..utils.types import MetricResults
 from .base import MetricBase
 from .registry import metric_registry
 
-if distance_available() and lxml_available() and apted_available():
-    import distance  # type: ignore
+with try_import() as ap_import_guard:
     from apted import APTED, Config  # type: ignore
     from apted.helpers import Tree  # type: ignore
+
+
+if not ap_import_guard.is_successful():
+    from ..utils.mocks import Config, Tree
+
+
+with try_import() as ds_import_guard:
+    import distance  # type: ignore
+
+with try_import() as lx_import_guard:
     from lxml import etree
 
 
@@ -56,7 +60,7 @@ class TableTree(Tree):
         tag: str,
         colspan: Optional[int] = None,
         rowspan: Optional[int] = None,
-        content: Optional[List[str]] = None,
+        content: Optional[list[str]] = None,
     ) -> None:
         self.tag = tag
         self.colspan = colspan
@@ -104,7 +108,7 @@ class TEDS:
 
     def __init__(self, structure_only: bool = False):
         self.structure_only = structure_only
-        self.__tokens__: List[str] = []
+        self.__tokens__: list[str] = []
 
     def tokenize(self, node: TableTree) -> None:
         """Tokenizes table cells"""
@@ -146,7 +150,7 @@ class TEDS:
             return new_node
         return None
 
-    def evaluate(self, inputs: Tuple[str, str]) -> float:
+    def evaluate(self, inputs: tuple[str, str]) -> float:
         """Computes TEDS score between the prediction and the ground truth of a
         given sample
         """
@@ -185,7 +189,7 @@ class TEDS:
         return 0.0
 
 
-def teds_metric(gt_list: List[str], predict_list: List[str], structure_only: bool) -> Tuple[float, int]:
+def teds_metric(gt_list: list[str], predict_list: list[str], structure_only: bool) -> tuple[float, int]:
     """
     Computes tree edit distance score (TEDS) between the prediction and the ground truth of a batch of samples. The
     approach to measure similarity of tables by means of their html representation has been adovacated in
@@ -218,13 +222,16 @@ class TedsMetric(MetricBase):
     """
 
     metric = teds_metric  # type: ignore
-    mapper = Page.from_image
+    mapper: Callable[[Image, LayoutType, list[LayoutType]], Page] = Page.from_image
+    text_container: LayoutType = LayoutType.WORD
+    floating_text_block_categories = [LayoutType.TABLE]
+
     structure_only = False
 
     @classmethod
     def dump(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> Tuple[List[str], List[str]]:
+    ) -> tuple[list[str], list[str]]:
         dataflow_gt.reset_state()
         dataflow_predictions.reset_state()
 
@@ -232,11 +239,11 @@ class TedsMetric(MetricBase):
         gt_dict = defaultdict(list)
         pred_dict = defaultdict(list)
         for dp_gt, dp_pred in zip(dataflow_gt, dataflow_predictions):
-            page_gt = cls.mapper(dp_gt, LayoutType.word, [LayoutType.table])
+            page_gt = cls.mapper(dp_gt, cls.text_container, cls.floating_text_block_categories)
             for table in page_gt.tables:
                 gt_dict[page_gt.image_id].append(table.html)
 
-            page_pred = cls.mapper(dp_pred, LayoutType.word, [LayoutType.table])
+            page_pred = cls.mapper(dp_pred, cls.text_container, cls.floating_text_block_categories)
             for table in page_pred.tables:
                 pred_dict[page_pred.image_id].append(table.html)
 
@@ -251,12 +258,12 @@ class TedsMetric(MetricBase):
     @classmethod
     def get_distance(
         cls, dataflow_gt: DataFlow, dataflow_predictions: DataFlow, categories: DatasetCategories
-    ) -> List[JsonDict]:
+    ) -> list[MetricResults]:
         html_gt_list, html_pr_list = cls.dump(dataflow_gt, dataflow_predictions, categories)
 
         score, num_samples = cls.metric(html_gt_list, html_pr_list, cls.structure_only)  # type: ignore
         return [{"teds_score": score, "num_samples": num_samples}]
 
     @classmethod
-    def get_requirements(cls) -> List[Requirement]:
+    def get_requirements(cls) -> list[Requirement]:
         return [get_apted_requirement(), get_distance_requirement(), get_lxml_requirement()]

deepdoctection/eval/tp_eval_callback.py

@@ -19,13 +19,15 @@
 Module for EvalCallback in Tensorpack
 """
 
+from __future__ import annotations
+
 from itertools import count
 from typing import Mapping, Optional, Sequence, Type, Union
 
+from lazy_imports import try_import
+
 from ..datasets import DatasetBase
-from ..extern.tpdetect import TPFrcnnDetector
-from ..pipe.base import PredictorPipelineComponent
-from ..utils.file_utils import tensorpack_available
+from ..pipe.base import PipelineComponent
 from ..utils.logger import LoggingRecord, logger
 from ..utils.metacfg import AttrDict
 from ..utils.settings import ObjectTypes
@@ -33,12 +35,15 @@ from .base import MetricBase
 from .eval import Evaluator
 
 # pylint: disable=import-error
-if tensorpack_available():
+with try_import() as import_guard:
     from tensorpack.callbacks import Callback
     from tensorpack.predict import OnlinePredictor
     from tensorpack.utils.gpu import get_num_gpu
 # pylint: enable=import-error
 
+if not import_guard.is_successful():
+    from ..utils.mocks import Callback
+
 
 # The following class is modified from
 # https://github.com/tensorpack/tensorpack/blob/master/examples/FasterRCNN/eval.py
@@ -53,15 +58,16 @@ class EvalCallback(Callback):  # pylint: disable=R0903
 
     _chief_only = False
 
-    def __init__(
+    def __init__(  # pylint: disable=W0231
         self,
         dataset: DatasetBase,
         category_names: Optional[Union[ObjectTypes, Sequence[ObjectTypes]]],
         sub_categories: Optional[Union[Mapping[ObjectTypes, ObjectTypes], Mapping[ObjectTypes, Sequence[ObjectTypes]]]],
         metric: Union[Type[MetricBase], MetricBase],
-        pipeline_component: PredictorPipelineComponent,
+        pipeline_component: PipelineComponent,
         in_names: str,
         out_names: str,
+        cfg: AttrDict,
         **build_eval_kwargs: str,
     ) -> None:
         """
@@ -83,12 +89,7 @@ class EvalCallback(Callback):  # pylint: disable=R0903
         self.num_gpu = get_num_gpu()
         self.category_names = category_names
         self.sub_categories = sub_categories
-        if not isinstance(pipeline_component.predictor, TPFrcnnDetector):
-            raise TypeError(
-                f"pipeline_component.predictor must be of type TPFrcnnDetector but is "
-                f"type {type(pipeline_component.predictor)}"
-            )
-        self.cfg = pipeline_component.predictor.model.cfg
+        self.cfg = cfg
         if _use_replicated(self.cfg):
             self.evaluator = Evaluator(dataset, pipeline_component, metric, num_threads=self.num_gpu * 2)
         else:
@@ -99,13 +100,9 @@ class EvalCallback(Callback):  # pylint: disable=R0903
             if self.evaluator.pipe_component is None:
                 raise TypeError("self.evaluator.pipe_component cannot be None")
             for idx, comp in enumerate(self.evaluator.pipe_component.pipe_components):
-                if not isinstance(comp, PredictorPipelineComponent):
-                    raise TypeError(f"comp must be of type PredictorPipelineComponent but is type {type(comp)}")
-                if not isinstance(comp.predictor, TPFrcnnDetector):
-                    raise TypeError(
-                        f"comp.predictor mus be of type TPFrcnnDetector but is of type {type(comp.predictor)}"
-                    )
-                comp.predictor.tp_predictor = self._build_predictor(idx % self.num_gpu)
+                if hasattr(comp, "predictor"):
+                    if hasattr(comp.predictor, "tp_predictor"):
+                        comp.predictor.tp_predictor = self._build_predictor(idx % self.num_gpu)
 
     def _build_predictor(self, idx: int) -> OnlinePredictor:
         return self.trainer.get_predictor(self.in_names, self.out_names, device=idx)

deepdoctection/extern/__init__.py

@@ -19,8 +19,8 @@
 Wrappers for models of external libraries as well as implementation of the Cascade-RCNN model of Tensorpack.
 """
 
-from ..utils.file_utils import detectron2_available, tensorpack_available
 from .base import *
+from .d2detect import *
 from .deskew import *
 from .doctrocr import *
 from .fastlang import *
@@ -30,9 +30,4 @@ from .model import *
 from .pdftext import *
 from .tessocr import *
 from .texocr import *  # type: ignore
-
-if tensorpack_available():
-    from .tpdetect import *
-
-if detectron2_available():
-    from .d2detect import *
+from .tpdetect import *