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

deepdoctection/pipe/sub_layout.py

@@ -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:
         """
@@ -181,10 +190,10 @@ class SubImageLayoutService(PredictorPipelineComponent):
         - Optionally invoke the DetectResultGenerator
         - Generate ImageAnnotations and dump to parent image and sub image.
         """
-        sub_image_anns = dp.get_annotation_iter(category_names=self.sub_image_name)
+        sub_image_anns = dp.get_annotation(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/d2_frcnn_train.py

@@ -21,7 +21,9 @@ Module for training Detectron2 `GeneralizedRCNN`
 from __future__ import annotations
 
 import copy
-from typing import Any, Dict, List, Mapping, Optional, Sequence, Type, Union
+import os
+from pathlib import Path
+from typing import Any, Mapping, Optional, Sequence, Type, Union
 
 from lazy_imports import try_import
 
@@ -33,11 +35,12 @@ from ..eval.eval import Evaluator
 from ..eval.registry import metric_registry
 from ..extern.d2detect import D2FrcnnDetector
 from ..mapper.d2struct import image_to_d2_frcnn_training
-from ..pipe.base import PredictorPipelineComponent
+from ..pipe.base import PipelineComponent
 from ..pipe.registry import pipeline_component_registry
 from ..utils.error import DependencyError
 from ..utils.file_utils import get_wandb_requirement, wandb_available
 from ..utils.logger import LoggingRecord, logger
+from ..utils.types import PathLikeOrStr
 from ..utils.utils import string_to_dict
 
 with try_import() as d2_import_guard:
@@ -58,8 +61,8 @@ with try_import() as wb_import_guard:
 
 
 def _set_config(
-    path_config_yaml: str,
-    conf_list: List[str],
+    path_config_yaml: PathLikeOrStr,
+    conf_list: list[str],
     dataset_train: DatasetBase,
     dataset_val: Optional[DatasetBase],
     metric_name: Optional[str],
@@ -74,7 +77,7 @@ def _set_config(
     cfg.WANDB.USE_WANDB = False
     cfg.WANDB.PROJECT = None
     cfg.WANDB.REPO = "deepdoctection"
-    cfg.merge_from_file(path_config_yaml)
+    cfg.merge_from_file(path_config_yaml.as_posix() if isinstance(path_config_yaml, Path) else path_config_yaml)
     cfg.merge_from_list(conf_list)
 
     cfg.TEST.DO_EVAL = (
@@ -89,7 +92,7 @@ def _set_config(
     return cfg
 
 
-def _update_for_eval(config_overwrite: List[str]) -> List[str]:
+def _update_for_eval(config_overwrite: list[str]) -> list[str]:
     ret = [item for item in config_overwrite if not "WANDB" in item]
     return ret
 
@@ -103,7 +106,7 @@ class WandbWriter(EventWriter):
         self,
         project: str,
         repo: str,
-        config: Optional[Union[Dict[str, Any], CfgNode]] = None,
+        config: Optional[Union[dict[str, Any], CfgNode]] = None,
         window_size: int = 20,
         **kwargs: Any,
     ):
@@ -145,7 +148,7 @@ class D2Trainer(DefaultTrainer):
         self.build_val_dict: Mapping[str, str] = {}
         super().__init__(cfg)
 
-    def build_hooks(self) -> List[HookBase]:
+    def build_hooks(self) -> list[HookBase]:
         """
         Overwritten from DefaultTrainer. This ensures that the EvalHook is being called before the writer and
         all metrics are being written to JSON, Tensorboard etc.
@@ -197,7 +200,7 @@ class D2Trainer(DefaultTrainer):
 
         return ret
 
-    def build_writers(self) -> List[EventWriter]:
+    def build_writers(self) -> list[EventWriter]:
         """
         Build a list of writers to be using `default_writers()`.
         If you'd like a different list of writers, you can overwrite it in
@@ -226,7 +229,7 @@ class D2Trainer(DefaultTrainer):
             dataset=self.dataset, mapper=self.mapper, total_batch_size=cfg.SOLVER.IMS_PER_BATCH
         )
 
-    def eval_with_dd_evaluator(self, **build_eval_kwargs: str) -> Union[List[Dict[str, Any]], Dict[str, Any]]:
+    def eval_with_dd_evaluator(self, **build_eval_kwargs: str) -> Union[list[dict[str, Any]], dict[str, Any]]:
         """
         Running the Evaluator. This method will be called from the `EvalHook`
 
@@ -243,7 +246,7 @@ class D2Trainer(DefaultTrainer):
     def setup_evaluator(
         self,
         dataset_val: DatasetBase,
-        pipeline_component: PredictorPipelineComponent,
+        pipeline_component: PipelineComponent,
         metric: Union[Type[MetricBase], MetricBase],
         build_val_dict: Optional[Mapping[str, str]] = None,
     ) -> None:
@@ -271,9 +274,7 @@ class D2Trainer(DefaultTrainer):
             self.build_val_dict = build_val_dict
         assert self.evaluator.pipe_component
         for comp in self.evaluator.pipe_component.pipe_components:
-            assert isinstance(comp, PredictorPipelineComponent)
-            assert isinstance(comp.predictor, D2FrcnnDetector)
-            comp.predictor.d2_predictor = None
+            comp.clear_predictor()
 
     @classmethod
     def build_evaluator(cls, cfg, dataset_name):  # type: ignore
@@ -281,11 +282,11 @@ class D2Trainer(DefaultTrainer):
 
 
 def train_d2_faster_rcnn(
-    path_config_yaml: str,
+    path_config_yaml: PathLikeOrStr,
     dataset_train: Union[str, DatasetBase],
-    path_weights: str,
-    config_overwrite: Optional[List[str]] = None,
-    log_dir: str = "train_log/frcnn",
+    path_weights: PathLikeOrStr,
+    config_overwrite: Optional[list[str]] = None,
+    log_dir: PathLikeOrStr = "train_log/frcnn",
     build_train_config: Optional[Sequence[str]] = None,
     dataset_val: Optional[DatasetBase] = None,
     build_val_config: Optional[Sequence[str]] = None,
@@ -342,13 +343,13 @@ def train_d2_faster_rcnn(
 
     assert cuda.device_count() > 0, "Has to train with GPU!"
 
-    build_train_dict: Dict[str, str] = {}
+    build_train_dict: dict[str, str] = {}
     if build_train_config is not None:
         build_train_dict = string_to_dict(",".join(build_train_config))
     if "split" not in build_train_dict:
         build_train_dict["split"] = "train"
 
-    build_val_dict: Dict[str, str] = {}
+    build_val_dict: dict[str, str] = {}
     if build_val_config is not None:
         build_val_dict = string_to_dict(",".join(build_val_config))
     if "split" not in build_val_dict:
@@ -358,9 +359,9 @@ def train_d2_faster_rcnn(
         config_overwrite = []
     conf_list = [
         "MODEL.WEIGHTS",
-        path_weights,
+        os.fspath(path_weights),
         "OUTPUT_DIR",
-        log_dir,
+        os.fspath(log_dir),
     ]
     for conf in config_overwrite:
         key, val = conf.split("=", maxsplit=1)
@@ -376,11 +377,13 @@ def train_d2_faster_rcnn(
     if metric_name is not None:
         metric = metric_registry.get(metric_name)
 
-    dataset = DatasetAdapter(dataset_train, True, image_to_d2_frcnn_training(False), True, **build_train_dict)
+    dataset = DatasetAdapter(
+        dataset_train, True, image_to_d2_frcnn_training(False), True, number_repetitions=-1, **build_train_dict
+    )
     augment_list = [ResizeShortestEdge(cfg.INPUT.MIN_SIZE_TRAIN, cfg.INPUT.MAX_SIZE_TRAIN), RandomFlip()]
     mapper = DatasetMapper(is_train=True, augmentations=augment_list, image_format="BGR")
 
-    logger.info(LoggingRecord(f"Config: \n {str(cfg)}", cfg.to_dict()))
+    logger.info(LoggingRecord(f"Config: \n {str(cfg)}", dict(cfg)))
 
     trainer = D2Trainer(cfg, dataset, mapper)
     trainer.resume_or_load()
@@ -391,7 +394,6 @@ def train_d2_faster_rcnn(
         detector = D2FrcnnDetector(path_config_yaml, path_weights, categories, config_overwrite, cfg.MODEL.DEVICE)
         pipeline_component_cls = pipeline_component_registry.get(pipeline_component_name)
         pipeline_component = pipeline_component_cls(detector)
-        assert isinstance(pipeline_component, PredictorPipelineComponent)
 
         if metric_name is not None:
             metric = metric_registry.get(metric_name)