deepdoctection 0.39.5__tar.gz → 0.39.7__tar.gz

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: deepdoctection
-Version: 0.39.5
+Version: 0.39.7
 Summary: Repository for Document AI
 Home-page: https://github.com/deepdoctection/deepdoctection
 Author: Dr. Janis Meyer
@@ -133,6 +133,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/__init__.py

@@ -25,7 +25,7 @@ from .utils.logger import LoggingRecord, logger
 
 # pylint: enable=wrong-import-position
 
-__version__ = "0.39.5"
+__version__ = "0.39.7"
 
 _IMPORT_STRUCTURE = {
     "analyzer": ["config_sanity_checks", "get_dd_analyzer", "ServiceFactory"],

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/datapoint/box.py

@@ -18,10 +18,11 @@
 """
 Implementation of BoundingBox class and related methods
 """
+from __future__ import annotations
 
 from dataclasses import dataclass
 from math import ceil, floor
-from typing import Optional, Sequence, no_type_check
+from typing import Optional, Sequence, Union, no_type_check
 
 import numpy as np
 import numpy.typing as npt
@@ -31,7 +32,7 @@ from numpy import float32
 from ..utils.error import BoundingBoxError
 from ..utils.file_utils import cocotools_available
 from ..utils.logger import LoggingRecord, logger
-from ..utils.types import PixelValues
+from ..utils.types import BoxCoordinate, PixelValues
 
 with try_import() as import_guard:
     import pycocotools.mask as coco_mask
@@ -142,96 +143,213 @@ def iou(boxes1: npt.NDArray[float32], boxes2: npt.NDArray[float32]) -> npt.NDArr
     return np_iou(boxes1, boxes2)
 
 
+RELATIVE_COORD_CONVERTER = 10**8
+
+
 @dataclass
 class BoundingBox:
     """
-    Rectangular bounding box dataclass for object detection. Store coordinates and allows several
-    representations. You can define an instance by passing the upper left point along with either height
-    and width or along with the lower right point. Pass absolute_coords = 'True' if you work with image
-    pixel coordinates. If you work with coordinates in the range between (0,1) then pass absolute_coords
-    ='False'. A bounding box is a disposable object. Do not change the coordinates once the have been set but define
-    a new box.
-
-    `absolute_coords` indicates, whether given coordinates are in absolute or in relative terms
-
-    `ulx`: upper left x
+    Rectangular bounding box that stores coordinates and allows different representations.
 
-    `uly`: upper left y
+    This implementation differs from the previous version by using internal integer storage with precision scaling
+    for both absolute and relative coordinates. Coordinates are stored internally as integers (_ulx, _uly, etc.)
+    with relative coordinates multiplied by RELATIVE_COORD_CONVERTER (10^8) for precision. Properties (ulx, uly, etc.)
+    handle the conversion between internal storage and exposed values.
 
-    `lrx`: lower right x
+    You can define an instance by passing:
+    - Upper left point (ulx, uly) + width and height, OR
+    - Upper left point (ulx, uly) + lower right point (lrx, lry)
 
-    `lry`: lower right y
-
-    `height`: height
-
-    `width`: width
+    Notes:
+    - When absolute_coords=True, coordinates will be rounded to integers
+    - When absolute_coords=False, coordinates must be between 0 and 1
+    - The box is validated on initialization to ensure coordinates are valid
     """
 
     absolute_coords: bool
-    ulx: float
-    uly: float
-    lrx: float = 0.0
-    lry: float = 0.0
-    height: float = 0.0
-    width: float = 0.0
+    _ulx: int = 0
+    _uly: int = 0
+    _lrx: int = 0
+    _lry: int = 0
+    _height: int = 0
+    _width: int = 0
+
+    def __init__(
+        self,
+        absolute_coords: bool,
+        ulx: BoxCoordinate,
+        uly: BoxCoordinate,
+        lrx: BoxCoordinate = 0,
+        lry: BoxCoordinate = 0,
+        width: BoxCoordinate = 0,
+        height: BoxCoordinate = 0,
+    ):
+        """
+        Initialize a BoundingBox instance with the specified coordinates.
+
+        This initializer supports two ways of defining a bounding box:
+        1. Using upper-left coordinates (ulx, uly) with width and height
+        2. Using upper-left (ulx, uly) and lower-right (lrx, lry) coordinates
+
+        When absolute_coords is True, coordinates are stored as integers.
+        When absolute_coords is False, coordinates are stored as scaled integers
+        (original float values * RELATIVE_COORD_CONVERTER) for precision.
+
+        :param absolute_coords: Whether coordinates are absolute pixels (True) or normalized [0,1] values (False)
+        :param ulx: Upper-left x-coordinate (float or int)
+        :param uly: Upper-left y-coordinate (float or int)
+        :param lrx: Lower-right x-coordinate (float or int), default 0
+        :param lry: Lower-right y-coordinate (float or int), default 0
+        :param width: Width of the bounding box (float or int), default 0
+        :param height: Height of the bounding box (float or int), default 0
+        """
+        self.absolute_coords = absolute_coords
+        if absolute_coords:
+            self._ulx = round(ulx)
+            self._uly = round(uly)
+            if lrx and lry:
+                self._lrx = round(lrx)
+                self._lry = round(lry)
+            if width and height:
+                self._width = round(width)
+                self._height = round(height)
+        else:
+            self._ulx = round(ulx * RELATIVE_COORD_CONVERTER)
+            self._uly = round(uly * RELATIVE_COORD_CONVERTER)
+            if lrx and lry:
+                self._lrx = round(lrx * RELATIVE_COORD_CONVERTER)
+                self._lry = round(lry * RELATIVE_COORD_CONVERTER)
+            if width and height:
+                self._width = round(width * RELATIVE_COORD_CONVERTER)
+                self._height = round(height * RELATIVE_COORD_CONVERTER)
+        if not self._width and not self._height:
+            self._width = self._lrx - self._ulx
+            self._height = self._lry - self._uly
+        if not self._lrx and not self._lry:
+            self._lrx = self._ulx + self._width
+            self._lry = self._uly + self._height
+        self.__post_init__()
 
     def __post_init__(self) -> None:
-        if self.width == 0.0:
-            if self.lrx is None:
+        if self._width == 0:
+            if self._lrx is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.width = self.lrx - self.ulx
-        if self.height == 0.0:
-            if self.lry is None:
+            self._width = self._lrx - self._ulx
+        if self._height == 0:
+            if self._lry is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.height = self.lry - self.uly
+            self._height = self._lry - self._uly
 
-        if self.lrx == 0.0:
-            if self.width is None:
+        if self._lrx == 0:
+            if self._width is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.lrx = self.ulx + self.width
-        if self.lry == 0.0:
-            if self.height is None:
+            self._lrx = self._ulx + self._width
+        if self._lry == 0:
+            if self._height is None:
                 raise BoundingBoxError("Bounding box not fully initialized")
-            self.lry = self.uly + self.height
+            self._lry = self._uly + self._height
 
-        if not (self.ulx >= 0.0 and self.uly >= 0.0):
-            raise BoundingBoxError("Bounding box ul must be >= (0.,0.)")
-        if not (self.height > 0.0 and self.width > 0.0):
+        if not (self._ulx >= 0 and self._uly >= 0):
+            raise BoundingBoxError("Bounding box ul must be >= (0,0)")
+        if not (self._height > 0 and self._width > 0):
             raise BoundingBoxError(
                 f"bounding box must have height and width >0. Check coords "
                 f"ulx: {self.ulx}, uly: {self.uly}, lrx: {self.lrx}, "
                 f"lry: {self.lry}."
             )
-        if not self.absolute_coords:
-            if not (self.ulx <= 1.0 and self.uly <= 1.0 and self.lrx <= 1.0 and self.lry <= 1.0):
-                raise BoundingBoxError("coordinates must be between 0 and 1")
+        if not self.absolute_coords and not (
+            0 <= self.ulx <= 1 and 0 <= self.uly <= 1 and 0 <= self.lrx <= 1 and 0 <= self.lry <= 1
+        ):
+            raise BoundingBoxError("coordinates must be between 0 and 1")
 
     @property
-    def cx(self) -> float:
-        """
-        Bounding box center x coordinate
-        """
+    def ulx(self) -> BoxCoordinate:
+        """ulx property"""
+        return self._ulx / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._ulx
+
+    @ulx.setter
+    def ulx(self, value: BoxCoordinate) -> None:
+        """ulx setter"""
+        self._ulx = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._width = self._lrx - self._ulx
+
+    @property
+    def uly(self) -> BoxCoordinate:
+        """uly property"""
+        return self._uly / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._uly
+
+    @uly.setter
+    def uly(self, value: BoxCoordinate) -> None:
+        """uly setter"""
+        self._uly = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._height = self._lry - self._uly
+
+    @property
+    def lrx(self) -> BoxCoordinate:
+        """lrx property"""
+        return self._lrx / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._lrx
+
+    @lrx.setter
+    def lrx(self, value: BoxCoordinate) -> None:
+        """lrx setter"""
+        self._lrx = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._width = self._lrx - self._ulx
+
+    @property
+    def lry(self) -> BoxCoordinate:
+        """lry property"""
+        return self._lry / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._lry
+
+    @lry.setter
+    def lry(self, value: BoxCoordinate) -> None:
+        """lry setter"""
+        self._lry = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._height = self._lry - self._uly
+
+    @property
+    def width(self) -> BoxCoordinate:
+        """width property"""
+        return self._width / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._width
+
+    @width.setter
+    def width(self, value: BoxCoordinate) -> None:
+        """width setter"""
+        self._width = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._lrx = self._ulx + self._width
+
+    @property
+    def height(self) -> BoxCoordinate:
+        """height property"""
+        return self._height / RELATIVE_COORD_CONVERTER if not self.absolute_coords else self._height
+
+    @height.setter
+    def height(self, value: BoxCoordinate) -> None:
+        """height setter"""
+        self._height = round(value * RELATIVE_COORD_CONVERTER) if not self.absolute_coords else round(value)
+        self._lry = self._uly + self._height
+
+    @property
+    def cx(self) -> BoxCoordinate:
+        """cx property"""
+        if self.absolute_coords:
+            return round(self.ulx + 0.5 * self.width)
         return self.ulx + 0.5 * self.width
 
     @property
-    def cy(self) -> float:
-        """
-        Bounding box center y coordinate
-        """
+    def cy(self) -> BoxCoordinate:
+        """cy property"""
+        if self.absolute_coords:
+            return round(self.uly + 0.5 * self.height)
         return self.uly + 0.5 * self.height
 
     @property
-    def center(self) -> list[float]:
-        """
-        Bounding box center [x,y]
-        """
-        return [self.cx, self.cy]
+    def center(self) -> tuple[BoxCoordinate, BoxCoordinate]:
+        """center property"""
+        return (self.cx, self.cy)
 
     @property
-    def area(self) -> float:
-        """
-        Bounding box area
-        """
+    def area(self) -> Union[int, float]:
+        """area property"""
         if self.absolute_coords:
             return self.width * self.height
         raise ValueError("Cannot calculate area, when bounding box coords are relative")
@@ -264,7 +382,7 @@ class BoundingBox:
             * np_poly_scale
         )
 
-    def to_list(self, mode: str, scale_x: float = 1.0, scale_y: float = 1.0) -> list[float]:
+    def to_list(self, mode: str, scale_x: float = 1.0, scale_y: float = 1.0) -> list[BoxCoordinate]:
         """
         Returns the coordinates as list
 
@@ -280,36 +398,62 @@ class BoundingBox:
         """
         assert mode in ("xyxy", "xywh", "poly"), "Not a valid mode"
         if mode == "xyxy":
-            return [
+            return (
+                [
+                    round(self.ulx * scale_x),
+                    round(self.uly * scale_y),
+                    round(self.lrx * scale_x),
+                    round(self.lry * scale_y),
+                ]
+                if self.absolute_coords
+                else [
+                    self.ulx * scale_x,
+                    self.uly * scale_y,
+                    self.lrx * scale_x,
+                    self.lry * scale_y,
+                ]
+            )
+        if mode == "xywh":
+            return (
+                [
+                    round(self.ulx * scale_x),
+                    round(self.uly * scale_y),
+                    round(self.width * scale_x),
+                    round(self.height * scale_y),
+                ]
+                if self.absolute_coords
+                else [self.ulx * scale_x, self.uly * scale_y, self.width * scale_x, self.height * scale_y]
+            )
+        return (
+            [
+                round(self.ulx * scale_x),
+                round(self.uly * scale_y),
+                round(self.lrx * scale_x),
+                round(self.uly * scale_y),
+                round(self.lrx * scale_x),
+                round(self.lry * scale_y),
+                round(self.ulx * scale_x),
+                round(self.lry * scale_y),
+            ]
+            if self.absolute_coords
+            else [
                 self.ulx * scale_x,
                 self.uly * scale_y,
                 self.lrx * scale_x,
+                self.uly * scale_y,
+                self.lrx * scale_x,
                 self.lry * scale_y,
-            ]
-        if mode == "xywh":
-            return [
                 self.ulx * scale_x,
-                self.uly * scale_y,
-                self.width * scale_x,
-                self.height * scale_y,
+                self.lry * scale_y,
             ]
-        return [
-            self.ulx * scale_x,
-            self.uly * scale_y,
-            self.lrx * scale_x,
-            self.uly * scale_y,
-            self.lrx * scale_x,
-            self.lry * scale_y,
-            self.ulx * scale_x,
-            self.lry * scale_y,
-        ]
+        )
 
     def transform(
         self,
         image_width: float,
         image_height: float,
         absolute_coords: bool = False,
-    ) -> "BoundingBox":
+    ) -> BoundingBox:
         """
         Transforms bounding box coordinates into absolute or relative coords. Internally, a new bounding box will be
         created. Changing coordinates requires width and height of the whole image.
@@ -320,8 +464,7 @@ class BoundingBox:
 
         :return: Either a list or np.array.
         """
-
-        if absolute_coords != self.absolute_coords:  # only transforming in this case
+        if absolute_coords != self.absolute_coords:
             if self.absolute_coords:
                 transformed_box = BoundingBox(
                     absolute_coords=not self.absolute_coords,
@@ -344,22 +487,26 @@ class BoundingBox:
     def __str__(self) -> str:
         return f"Bounding Box ulx: {self.ulx}, uly: {self.uly}, lrx: {self.lrx}, lry: {self.lry}"
 
+    def __repr__(self) -> str:
+        return (
+            f"BoundingBox(absolute_coords={self.absolute_coords}, ulx={self.ulx}, uly={self.uly}, lrx={self.lrx},"
+            f" lry={self.lry}, width={self.width}, height={self.height})"
+        )
+
     @staticmethod
     def remove_keys() -> list[str]:
-        """
-        A list of attributes to suspend from as_dict creation.
-        """
-        return ["height", "width"]
+        """Removing keys when converting the dataclass object to a dict"""
+        return ["_height", "_width"]
+
+    @staticmethod
+    def replace_keys() -> dict[str, str]:
+        """Replacing keys when converting the dataclass object to a dict. Useful for backward compatibility"""
+        return {"_ulx": "ulx", "_uly": "uly", "_lrx": "lrx", "_lry": "lry"}
 
     @classmethod
     @no_type_check
-    def from_dict(cls, **kwargs) -> "BoundingBox":
-        """
-        Create `BoundingBox` instance from dict
-
-        :param kwargs: dict with  `BoundingBox` attributes
-        :return: Initialized BoundingBox
-        """
+    def from_dict(cls, **kwargs) -> BoundingBox:
+        """from dict"""
         return cls(**kwargs)
 
 

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/datapoint/convert.py

@@ -65,6 +65,10 @@ def as_dict(obj: Any, dict_factory) -> Union[Any]:  # type: ignore
             if hasattr(obj, "remove_keys"):
                 if attribute.name in obj.remove_keys():
                     continue
+            if hasattr(obj, "replace_keys"):
+                old_to_new_keys = obj.replace_keys()
+                if attribute.name in old_to_new_keys:
+                    attribute.name = obj.replace_keys()[attribute.name]
             result.append((attribute.name, value))
         return dict_factory(result)
     if isinstance(obj, (list, tuple)):

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/datapoint/view.py

@@ -433,7 +433,7 @@ class Table(Layout):
             filter(
                 lambda c: column_number in (c.column_number, c.column_number + c.column_span - 1),  # type: ignore
                 all_cells,
-            )  # type: ignore
+            )
         )
         column_cells.sort(key=lambda c: c.row_number)  # type: ignore
         return column_cells  # type: ignore

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/datasets/registry.py

@@ -24,7 +24,7 @@ import catalogue  # type: ignore
 from tabulate import tabulate
 from termcolor import colored
 
-from .base import DatasetBase
+from .base import CustomDataset, DatasetBase
 
 __all__ = ["dataset_registry", "get_dataset", "print_dataset_infos"]
 
@@ -68,7 +68,10 @@ def print_dataset_infos(add_license: bool = True, add_info: bool = True) -> None
 
     for dataset in data.items():
         info = [dataset[0]]
-        ds = dataset[1]()
+        if isinstance(dataset[1], CustomDataset):
+            ds = dataset[1]
+        else:
+            ds = dataset[1]()
         info.append(ds.dataset_info.type)
         if add_license:
             info.append(ds.dataset_info.license)  # pylint: disable=W0212

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/pipe/sub_layout.py

@@ -123,7 +123,7 @@ class DetectResultGenerator:
         """
         sane_detect_results = []
         for detect_result in detect_result_list:
-            if detect_result.box:
+            if detect_result.box is not None:
                 ulx, uly, lrx, lry = detect_result.box
                 if ulx >= 0 and lrx - ulx >= 0 and uly >= 0 and lry - uly >= 0:
                     sane_detect_results.append(detect_result)

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/train/hf_detr_train.py

@@ -37,6 +37,8 @@ from ..extern.hfdetr import HFDetrDerivedDetector
 from ..mapper.hfstruct import DetrDataCollator, image_to_hf_detr_training
 from ..pipe.base import PipelineComponent
 from ..pipe.registry import pipeline_component_registry
+from ..utils.error import DependencyError
+from ..utils.file_utils import wandb_available
 from ..utils.logger import LoggingRecord, logger
 from ..utils.types import PathLikeOrStr
 from ..utils.utils import string_to_dict
@@ -56,6 +58,9 @@ with try_import() as hf_import_guard:
         TrainingArguments,
     )
 
+with try_import() as wb_import_guard:
+    import wandb
+
 
 class DetrDerivedTrainer(Trainer):
     """
@@ -74,16 +79,18 @@ class DetrDerivedTrainer(Trainer):
         args: TrainingArguments,
         data_collator: DetrDataCollator,
         train_dataset: DatasetAdapter,
+        eval_dataset: Optional[DatasetBase] = None,
     ):
         self.evaluator: Optional[Evaluator] = None
         self.build_eval_kwargs: Optional[dict[str, Any]] = None
-        super().__init__(model, args, data_collator, train_dataset)
+        super().__init__(model, args, data_collator, train_dataset, eval_dataset=eval_dataset)
 
     def setup_evaluator(
         self,
         dataset_val: DatasetBase,
         pipeline_component: PipelineComponent,
         metric: Union[Type[MetricBase], MetricBase],
+        run: Optional[wandb.sdk.wandb_run.Run] = None,
         **build_eval_kwargs: Union[str, int],
     ) -> None:
         """
@@ -93,10 +100,11 @@ class DetrDerivedTrainer(Trainer):
         :param dataset_val: dataset on which to run evaluation
         :param pipeline_component: pipeline component to plug into the evaluator
         :param metric: A metric class
+        :param run: WandB run
         :param build_eval_kwargs:
         """
 
-        self.evaluator = Evaluator(dataset_val, pipeline_component, metric, num_threads=1)
+        self.evaluator = Evaluator(dataset_val, pipeline_component, metric, num_threads=1, run=run)
         assert self.evaluator.pipe_component
         for comp in self.evaluator.pipe_component.pipe_components:
             comp.clear_predictor()
@@ -205,12 +213,19 @@ def train_hf_detr(
         "remove_unused_columns": False,
         "per_device_train_batch_size": 2,
         "max_steps": number_samples,
-        "evaluation_strategy": (
+        "eval_strategy": (
             "steps"
-            if (dataset_val is not None and metric is not None and pipeline_component_name is not None)
+            if (
+                dataset_val is not None
+                and (metric is not None or metric_name is not None)
+                and pipeline_component_name is not None
+            )
             else "no"
         ),
         "eval_steps": 5000,
+        "use_wandb": False,
+        "wandb_project": None,
+        "wandb_repo": "deepdoctection",
     }
 
     for conf in config_overwrite:
@@ -224,6 +239,23 @@ def train_hf_detr(
                 pass
         conf_dict[key] = val
 
+    use_wandb = conf_dict.pop("use_wandb")
+    wandb_project = str(conf_dict.pop("wandb_project"))
+    wandb_repo = str(conf_dict.pop("wandb_repo"))
+
+    # Initialize Wandb, if necessary
+    run = None
+    if use_wandb:
+        if not wandb_available():
+            raise DependencyError("WandB must be installed separately")
+        run = wandb.init(project=wandb_project, config=conf_dict)
+        run._label(repo=wandb_repo)  # pylint: disable=W0212
+        os.environ["WANDB_DISABLED"] = "False"
+        os.environ["WANDB_WATCH"] = "True"
+        os.environ["WANDB_PROJECT"] = wandb_project
+    else:
+        os.environ["WANDB_DISABLED"] = "True"
+
     # Will inform about dataloader warnings if max_steps exceeds length of dataset
     if conf_dict["max_steps"] > number_samples:  # type: ignore
         logger.warning(
@@ -232,7 +264,7 @@ def train_hf_detr(
             )
         )
 
-    arguments = TrainingArguments(**conf_dict)
+    arguments = TrainingArguments(**conf_dict)  # pylint: disable=E1123
     logger.info(LoggingRecord(f"Config: \n {arguments.to_dict()}", arguments.to_dict()))
 
     id2label = {int(k) - 1: v for v, k in categories_dict_name_as_key.items()}
@@ -252,9 +284,9 @@ def train_hf_detr(
         pretrained_model_name_or_path=path_feature_extractor_config_json
     )
     data_collator = DetrDataCollator(feature_extractor)
-    trainer = DetrDerivedTrainer(model, arguments, data_collator, dataset)
+    trainer = DetrDerivedTrainer(model, arguments, data_collator, dataset, eval_dataset=dataset_val)
 
-    if arguments.evaluation_strategy in (IntervalStrategy.STEPS,):
+    if arguments.eval_strategy in (IntervalStrategy.STEPS,):
         categories = dataset_val.dataflow.categories.get_categories(filtered=True)  # type: ignore
         detector = HFDetrDerivedDetector(
             path_config_json, path_weights, path_feature_extractor_config_json, categories  # type: ignore
@@ -266,6 +298,6 @@ def train_hf_detr(
             metric = metric_registry.get(metric_name)
         assert metric is not None
 
-        trainer.setup_evaluator(dataset_val, pipeline_component, metric)  # type: ignore
+        trainer.setup_evaluator(dataset_val, pipeline_component, metric, run, **build_val_dict)  # type: ignore
 
     trainer.train()

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/train/hf_layoutlm_train.py

@@ -395,7 +395,7 @@ def train_hf_layoutlm(
         "remove_unused_columns": False,
         "per_device_train_batch_size": 8,
         "max_steps": number_samples,
-        "evaluation_strategy": (
+        "eval_strategy": (
             "steps"
             if (dataset_val is not None and metric is not None and pipeline_component_name is not None)
             else "no"
@@ -475,7 +475,7 @@ def train_hf_layoutlm(
     )
     trainer = LayoutLMTrainer(model, arguments, data_collator, dataset, eval_dataset=dataset_val)
 
-    if arguments.evaluation_strategy in (IntervalStrategy.STEPS,):
+    if arguments.eval_strategy in (IntervalStrategy.STEPS,):
         assert metric is not None  # silence mypy
         if dataset_type == DatasetType.SEQUENCE_CLASSIFICATION:
             categories = dataset_val.dataflow.categories.get_categories(filtered=True)  # type: ignore

{deepdoctection-0.39.5 → deepdoctection-0.39.7}/deepdoctection/utils/types.py

@@ -63,7 +63,7 @@ else:
 
 
 JsonDict = dict[str, Any]
-
+BoxCoordinate = Union[int, float]
 
 # Some common deepdoctection dict-types
 AnnotationDict: TypeAlias = dict[str, Any]