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

deepdoctection/pipe/{cell.py → sub_layout.py}

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# File: cell.py
+# File: sub_layout.py
 
 # Copyright 2021 Dr. Janis Meyer. All rights reserved.
 #
@@ -18,9 +18,11 @@
 """
 Module for cell detection pipeline component
 """
+from __future__ import annotations
+
 from collections import Counter
-from copy import deepcopy
-from typing import Dict, List, Mapping, Optional, Sequence, Union
+from types import MappingProxyType
+from typing import Mapping, Optional, Sequence, Union
 
 import numpy as np
 
@@ -28,10 +30,10 @@ from ..datapoint.annotation import ImageAnnotation
 from ..datapoint.box import crop_box_from_image
 from ..datapoint.image import Image
 from ..extern.base import DetectionResult, ObjectDetector, PdfMiner
-from ..utils.detection_types import ImageType, JsonDict
-from ..utils.settings import ObjectTypes, Relationships
+from ..utils.settings import ObjectTypes, Relationships, TypeOrStr, get_type
 from ..utils.transform import PadTransform
-from .base import PredictorPipelineComponent
+from ..utils.types import PixelValues
+from .base import MetaAnnotation, PipelineComponent
 from .registry import pipeline_component_registry
 
 
@@ -47,9 +49,9 @@ class DetectResultGenerator:
 
     def __init__(
         self,
-        categories: Mapping[str, ObjectTypes],
-        group_categories: Optional[List[List[str]]] = None,
-        exclude_category_ids: Optional[Sequence[str]] = None,
+        categories: Mapping[int, ObjectTypes],
+        group_categories: Optional[list[list[int]]] = None,
+        exclude_category_ids: Optional[Sequence[int]] = None,
         absolute_coords: bool = True,
     ) -> None:
         """
@@ -59,7 +61,7 @@ class DetectResultGenerator:
                                  grouping category ids.
         :param absolute_coords: 'absolute_coords' value to be set in 'DetectionResult'
         """
-        self.categories = categories
+        self.categories = MappingProxyType(dict(categories.items()))
         self.width: Optional[int] = None
         self.height: Optional[int] = None
         if group_categories is None:
@@ -71,7 +73,7 @@ class DetectResultGenerator:
         self.dummy_for_group_generated = [False for _ in self.group_categories]
         self.absolute_coords = absolute_coords
 
-    def create_detection_result(self, detect_result_list: List[DetectionResult]) -> List[DetectionResult]:
+    def create_detection_result(self, detect_result_list: list[DetectionResult]) -> list[DetectionResult]:
         """
         Adds DetectResults for which no object was detected to the list.
 
@@ -100,8 +102,8 @@ class DetectResultGenerator:
         self.dummy_for_group_generated = self._initialize_dummy_for_group_generated()
         return detect_result_list
 
-    def _create_condition(self, detect_result_list: List[DetectionResult]) -> Dict[str, int]:
-        count = Counter([str(ann.class_id) for ann in detect_result_list])
+    def _create_condition(self, detect_result_list: list[DetectionResult]) -> dict[int, int]:
+        count = Counter([ann.class_id for ann in detect_result_list])
         cat_to_group_sum = {}
         for group in self.group_categories:
             group_sum = 0
@@ -111,7 +113,7 @@ class DetectResultGenerator:
                 cat_to_group_sum[el] = group_sum
         return cat_to_group_sum
 
-    def _dummy_for_group_generated(self, category_id: str) -> bool:
+    def _dummy_for_group_generated(self, category_id: int) -> bool:
         for idx, group in enumerate(self.group_categories):
             if category_id in group:
                 is_generated = self.dummy_for_group_generated[idx]
@@ -119,12 +121,12 @@ class DetectResultGenerator:
                 return is_generated
         return False
 
-    def _initialize_dummy_for_group_generated(self) -> List[bool]:
+    def _initialize_dummy_for_group_generated(self) -> list[bool]:
         return [False for _ in self.group_categories]
 
 
 @pipeline_component_registry.register("SubImageLayoutService")
-class SubImageLayoutService(PredictorPipelineComponent):
+class SubImageLayoutService(PipelineComponent):
     """
     Component in which the selected ImageAnnotation can be selected with cropped images and presented to a detector.
 
@@ -144,8 +146,8 @@ class SubImageLayoutService(PredictorPipelineComponent):
     def __init__(
         self,
         sub_image_detector: ObjectDetector,
-        sub_image_names: Union[str, List[str]],
-        category_id_mapping: Optional[Dict[int, int]] = None,
+        sub_image_names: Union[str, Sequence[TypeOrStr]],
+        category_id_mapping: Optional[dict[int, int]] = None,
         detect_result_generator: Optional[DetectResultGenerator] = None,
         padder: Optional[PadTransform] = None,
     ):
@@ -163,16 +165,23 @@ class SubImageLayoutService(PredictorPipelineComponent):
                         inverse coordinate transformation.
         """
 
-        if isinstance(sub_image_names, str):
-            sub_image_names = [sub_image_names]
-
-        self.sub_image_name = sub_image_names
+        self.sub_image_name = (
+            (get_type(sub_image_names),)
+            if isinstance(sub_image_names, str)
+            else tuple((get_type(cat) for cat in sub_image_names))
+        )
         self.category_id_mapping = category_id_mapping
         self.detect_result_generator = detect_result_generator
         self.padder = padder
-        super().__init__(self._get_name(sub_image_detector.name), sub_image_detector)
+        self.predictor = sub_image_detector
+        super().__init__(self._get_name(sub_image_detector.name), self.predictor.model_id)
         if self.detect_result_generator is not None:
-            assert self.detect_result_generator.categories == self.predictor.categories  # type: ignore
+            if self.detect_result_generator.categories != self.predictor.categories.get_categories():
+                raise ValueError(
+                    f"The categories of the 'detect_result_generator' must be the same as the categories of the "
+                    f"'sub_image_detector'. Got {self.detect_result_generator.categories} #"
+                    f"and {self.predictor.categories.get_categories()}."
+                )
 
     def serve(self, dp: Image) -> None:
         """
@@ -184,7 +193,7 @@ class SubImageLayoutService(PredictorPipelineComponent):
         sub_image_anns = dp.get_annotation_iter(category_names=self.sub_image_name)
         for sub_image_ann in sub_image_anns:
             np_image = self.prepare_np_image(sub_image_ann)
-            detect_result_list = self.predictor.predict(np_image)  # type: ignore
+            detect_result_list = self.predictor.predict(np_image)
             if self.padder and detect_result_list:
                 boxes = np.array([detect_result.box for detect_result in detect_result_list])
                 boxes_orig = self.padder.inverse_apply_coords(boxes)
@@ -203,23 +212,21 @@ class SubImageLayoutService(PredictorPipelineComponent):
                         )
                 self.dp_manager.set_image_annotation(detect_result, sub_image_ann.annotation_id)
 
-    def get_meta_annotation(self) -> JsonDict:
-        assert isinstance(self.predictor, (ObjectDetector, PdfMiner))
-        return dict(
-            [
-                ("image_annotations", self.predictor.possible_categories()),
-                ("sub_categories", {}),
-                # implicit setup of relations by using set_image_annotation with explicit annotation_id
-                ("relationships", {parent: {Relationships.child} for parent in self.sub_image_name}),
-                ("summaries", []),
-            ]
+    def get_meta_annotation(self) -> MetaAnnotation:
+        if not isinstance(self.predictor, (ObjectDetector, PdfMiner)):
+            raise ValueError(f"predictor must be of type ObjectDetector but is of type {type(self.predictor)}")
+        return MetaAnnotation(
+            image_annotations=self.predictor.get_category_names(),
+            sub_categories={},
+            relationships={get_type(parent): {Relationships.CHILD} for parent in self.sub_image_name},
+            summaries=(),
         )
 
     @staticmethod
     def _get_name(predictor_name: str) -> str:
         return f"sub_image_{predictor_name}"
 
-    def clone(self) -> "PredictorPipelineComponent":
+    def clone(self) -> SubImageLayoutService:
         predictor = self.predictor.clone()
         padder_clone = None
         if self.padder:
@@ -228,13 +235,13 @@ class SubImageLayoutService(PredictorPipelineComponent):
             raise ValueError(f"predictor must be of type ObjectDetector but is of type {type(predictor)}")
         return self.__class__(
             predictor,
-            deepcopy(self.sub_image_name),
-            deepcopy(self.category_id_mapping),
-            deepcopy(self.detect_result_generator),
+            self.sub_image_name,
+            self.category_id_mapping,
+            self.detect_result_generator,
             padder_clone,
         )
 
-    def prepare_np_image(self, sub_image_ann: ImageAnnotation) -> ImageType:
+    def prepare_np_image(self, sub_image_ann: ImageAnnotation) -> PixelValues:
         """Maybe crop and pad a np_array before passing it to the predictor.
 
         Note that we currently assume to a two level hierachy of images, e.g. we can crop a sub-image from the base
@@ -256,3 +263,6 @@ class SubImageLayoutService(PredictorPipelineComponent):
         if self.padder:
             np_image = self.padder.apply_image(np_image)
         return np_image
+
+    def clear_predictor(self) -> None:
+        self.predictor.clear_model()

deepdoctection/pipe/text.py

@@ -18,24 +18,27 @@
 """
 Module for text extraction pipeline component
 """
+
+from __future__ import annotations
+
 from copy import deepcopy
-from typing import List, Optional, Sequence, Tuple, Union
+from typing import Optional, Sequence, Union
 
 from ..datapoint.annotation import ImageAnnotation
 from ..datapoint.image import Image
 from ..extern.base import ObjectDetector, PdfMiner, TextRecognizer
 from ..extern.tessocr import TesseractOcrDetector
-from ..utils.detection_types import ImageType, JsonDict
 from ..utils.error import ImageError
-from ..utils.settings import PageType, TypeOrStr, WordType, get_type
-from .base import PredictorPipelineComponent
+from ..utils.settings import ObjectTypes, PageType, TypeOrStr, WordType, get_type
+from ..utils.types import PixelValues
+from .base import MetaAnnotation, PipelineComponent
 from .registry import pipeline_component_registry
 
 __all__ = ["TextExtractionService"]
 
 
 @pipeline_component_registry.register("TextExtractionService")
-class TextExtractionService(PredictorPipelineComponent):
+class TextExtractionService(PipelineComponent):
     """
     Pipeline component for extracting text. Any detector can be selected, provided that it can evaluate a
     numpy array as an image.
@@ -83,11 +86,13 @@ class TextExtractionService(PredictorPipelineComponent):
         if extract_from_roi is None:
             extract_from_roi = []
         self.extract_from_category = (
-            [get_type(extract_from_roi)]
+            (get_type(extract_from_roi),)
             if isinstance(extract_from_roi, str)
-            else [get_type(roi_category) for roi_category in extract_from_roi]
+            else tuple((get_type(roi_category) for roi_category in extract_from_roi))
         )
-        super().__init__(self._get_name(text_extract_detector.name), text_extract_detector)
+
+        self.predictor = text_extract_detector
+        super().__init__(self._get_name(text_extract_detector.name), self.predictor.model_id)
         if self.extract_from_category:
             if not isinstance(self.predictor, (ObjectDetector, TextRecognizer)):
                 raise TypeError(
@@ -95,9 +100,8 @@ class TextExtractionService(PredictorPipelineComponent):
                     f"TextRecognizer. Got {type(self.predictor)}"
                 )
         if run_time_ocr_language_selection:
-            assert isinstance(
-                self.predictor, TesseractOcrDetector
-            ), "Only TesseractOcrDetector supports multiple languages"
+            if not isinstance(self.predictor, TesseractOcrDetector):
+                raise TypeError("Only TesseractOcrDetector supports multiple languages")
 
         self.run_time_ocr_language_selection = run_time_ocr_language_selection
         self.skip_if_text_extracted = skip_if_text_extracted
@@ -120,7 +124,7 @@ class TextExtractionService(PredictorPipelineComponent):
             else:
                 width, height = None, None
                 if self.run_time_ocr_language_selection:
-                    self.predictor.set_language(dp.summary.get_sub_category(PageType.language).value)  # type: ignore
+                    self.predictor.set_language(dp.summary.get_sub_category(PageType.LANGUAGE).value)  # type: ignore
                 detect_result_list = self.predictor.predict(predictor_input)  # type: ignore
                 if isinstance(self.predictor, PdfMiner):
                     width, height = self.predictor.get_width_height(predictor_input)  # type: ignore
@@ -134,15 +138,15 @@ class TextExtractionService(PredictorPipelineComponent):
                         )
                     if detect_ann_id is not None:
                         self.dp_manager.set_container_annotation(
-                            WordType.characters,
+                            WordType.CHARACTERS,
                             None,
-                            WordType.characters,
+                            WordType.CHARACTERS,
                             detect_ann_id,
                             detect_result.text if detect_result.text is not None else "",
                             detect_result.score,
                         )
 
-    def get_text_rois(self, dp: Image) -> Sequence[Union[Image, ImageAnnotation, List[ImageAnnotation]]]:
+    def get_text_rois(self, dp: Image) -> Sequence[Union[Image, ImageAnnotation, list[ImageAnnotation]]]:
         """
         Return image rois based on selected categories. As this selection makes only sense for specific text extractors
         (e.g. those who do proper OCR and do not mine from text from native pdfs) it will do some sanity checks.
@@ -151,7 +155,7 @@ class TextExtractionService(PredictorPipelineComponent):
         :return: list of ImageAnnotation or Image
         """
         if self.skip_if_text_extracted:
-            text_categories = self.predictor.possible_categories()  # type: ignore
+            text_categories = self.predictor.get_category_names()
             text_anns = dp.get_annotation(category_names=text_categories)
             if text_anns:
                 return []
@@ -163,8 +167,8 @@ class TextExtractionService(PredictorPipelineComponent):
         return [dp]
 
     def get_predictor_input(
-        self, text_roi: Union[Image, ImageAnnotation, List[ImageAnnotation]]
-    ) -> Optional[Union[bytes, ImageType, List[Tuple[str, ImageType]], int]]:
+        self, text_roi: Union[Image, ImageAnnotation, list[ImageAnnotation]]
+    ) -> Optional[Union[bytes, PixelValues, list[tuple[str, PixelValues]], int]]:
         """
         Return raw input for a given `text_roi`. This can be a numpy array or pdf bytes and depends on the chosen
         predictor.
@@ -191,38 +195,35 @@ class TextExtractionService(PredictorPipelineComponent):
             return text_roi.pdf_bytes
         return 1
 
-    def get_meta_annotation(self) -> JsonDict:
+    def get_meta_annotation(self) -> MetaAnnotation:
+        sub_cat_dict: dict[ObjectTypes, set[ObjectTypes]]
         if self.extract_from_category:
-            sub_cat_dict = {category: {WordType.characters} for category in self.extract_from_category}
+            sub_cat_dict = {category: {WordType.CHARACTERS} for category in self.extract_from_category}
         else:
             if not isinstance(self.predictor, (ObjectDetector, PdfMiner)):
                 raise TypeError(
                     f"self.predictor must be of type ObjectDetector or PdfMiner but is of type "
                     f"{type(self.predictor)}"
                 )
-            sub_cat_dict = {category: {WordType.characters} for category in self.predictor.possible_categories()}
-        return dict(
-            [
-                (
-                    "image_annotations",
-                    (
-                        self.predictor.possible_categories()
-                        if isinstance(self.predictor, (ObjectDetector, PdfMiner))
-                        else []
-                    ),
-                ),
-                ("sub_categories", sub_cat_dict),
-                ("relationships", {}),
-                ("summaries", []),
-            ]
+            sub_cat_dict = {category: {WordType.CHARACTERS} for category in self.predictor.get_category_names()}
+        return MetaAnnotation(
+            image_annotations=self.predictor.get_category_names()
+            if isinstance(self.predictor, (ObjectDetector, PdfMiner))
+            else (),
+            sub_categories=sub_cat_dict,
+            relationships={},
+            summaries=(),
         )
 
     @staticmethod
     def _get_name(text_detector_name: str) -> str:
         return f"text_extract_{text_detector_name}"
 
-    def clone(self) -> "PredictorPipelineComponent":
+    def clone(self) -> TextExtractionService:
         predictor = self.predictor.clone()
         if not isinstance(predictor, (ObjectDetector, PdfMiner, TextRecognizer)):
             raise ImageError(f"predictor must be of type ObjectDetector or PdfMiner, but is of type {type(predictor)}")
         return self.__class__(predictor, deepcopy(self.extract_from_category), self.run_time_ocr_language_selection)
+
+    def clear_predictor(self) -> None:
+        self.predictor.clear_model()

deepdoctection/pipe/transform.py

@@ -20,15 +20,16 @@ Module for transform style pipeline components. These pipeline components are us
 on images (e.g. deskew, de-noising or more general GAN like operations.
 """
 
+from __future__ import annotations
+
 from ..datapoint.image import Image
 from ..extern.base import ImageTransformer
-from ..utils.detection_types import JsonDict
-from .base import ImageTransformPipelineComponent
+from .base import MetaAnnotation, PipelineComponent
 from .registry import pipeline_component_registry
 
 
 @pipeline_component_registry.register("SimpleTransformService")
-class SimpleTransformService(ImageTransformPipelineComponent):
+class SimpleTransformService(PipelineComponent):
     """
     Pipeline component for transforming an image. The service is designed for applying transform predictors that
     take an image as numpy array as input and return the same. The service itself will change the underlying metadata
@@ -44,7 +45,8 @@ class SimpleTransformService(ImageTransformPipelineComponent):
 
         :param transform_predictor: image transformer
         """
-        super().__init__(self._get_name(transform_predictor.name), transform_predictor)
+        self.transform_predictor = transform_predictor
+        super().__init__(self._get_name(transform_predictor.name), self.transform_predictor.model_id)
 
     def serve(self, dp: Image) -> None:
         if dp.annotations:
@@ -60,26 +62,27 @@ class SimpleTransformService(ImageTransformPipelineComponent):
             self.dp_manager.datapoint.clear_image(True)
             self.dp_manager.datapoint.image = transformed_image
             self.dp_manager.set_summary_annotation(
-                summary_key=self.transform_predictor.possible_category(),
-                summary_name=self.transform_predictor.possible_category(),
+                summary_key=self.transform_predictor.get_category_names()[0],
+                summary_name=self.transform_predictor.get_category_names()[0],
                 summary_number=None,
-                summary_value=getattr(detection_result, self.transform_predictor.possible_category().value, None),
+                summary_value=getattr(detection_result, self.transform_predictor.get_category_names()[0].value, None),
                 summary_score=detection_result.score,
             )
 
-    def clone(self) -> "SimpleTransformService":
+    def clone(self) -> SimpleTransformService:
         return self.__class__(self.transform_predictor)
 
-    def get_meta_annotation(self) -> JsonDict:
-        return dict(
-            [
-                ("image_annotations", []),
-                ("sub_categories", {}),
-                ("relationships", {}),
-                ("summaries", [self.transform_predictor.possible_category()]),
-            ]
+    def get_meta_annotation(self) -> MetaAnnotation:
+        return MetaAnnotation(
+            image_annotations=(),
+            sub_categories={},
+            relationships={},
+            summaries=self.transform_predictor.get_category_names(),
         )
 
     @staticmethod
     def _get_name(transform_name: str) -> str:
         return f"simple_transform_{transform_name}"
+
+    def clear_predictor(self) -> None:
+        pass

deepdoctection/train/__init__.py

@@ -19,20 +19,14 @@
 Init module for train package
 """
 
-from ..utils.file_utils import (
-    detectron2_available,
-    pytorch_available,
-    tensorpack_available,
-    tf_available,
-    transformers_available,
-)
+from ..utils.file_utils import detectron2_available, tensorpack_available, transformers_available
 
-if tf_available() and tensorpack_available():
-    from .tp_frcnn_train import train_faster_rcnn
-
-if pytorch_available() and detectron2_available():
+if detectron2_available():
     from .d2_frcnn_train import train_d2_faster_rcnn
 
-if pytorch_available() and transformers_available():
+if transformers_available():
     from .hf_detr_train import train_hf_detr
     from .hf_layoutlm_train import train_hf_layoutlm
+
+if tensorpack_available():
+    from .tp_frcnn_train import train_faster_rcnn