deepvisiontools 0.0.4__tar.gz → 0.2.0__tar.gz

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: deepvisiontools
-Version: 0.0.4
-Summary: Overlay of PyTorch to generalize trainning and inference processes for detection & instance segmentation tasks.
-Author-email: Lucas Bernigaud Samatan <lucas.bernigaud-samatan@inrae.fr>, Jordan Bernigaud Samatan <jordan.bernigaud-samatan@inrae.fr>
-Maintainer-email: Jordan Bernigaud Samatan <jordan.bernigaud-samatan@inrae.fr>
+Version: 0.2.0
+Summary: Overlay of PyTorch to generalize trainning and inference processes for detection, instance segmentation and semantic segmentation tasks.
+Author-email: Lucas Bernigaud Samatan <lucas.bernigaud-samatan@inrae.fr>, Jordan Bernigaud Samatan <jordan.bernigaud-samatan@inrae.fr>, Paul Faucher <paul.faucher@inrae.fr>
+Maintainer-email: Jordan Bernigaud Samatan <jordan.bernigaud-samatan@inrae.fr>, Lucas Bernigaud Samatan <lucas.bernigaud-samatan@inrae.fr>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
                                Version 3, 19 November 2007
         
@@ -670,20 +670,23 @@ Project-URL: Homepage, https://forgemia.inra.fr/ue-apc/librairies/python/deepvis
 Project-URL: Issues, https://forgemia.inra.fr/ue-apc/librairies/python/deepvisiontools_v1/-/issues
 Project-URL: Documentation, https://deepvisiontools.readthedocs.io/en/latest/
 Project-URL: Repository, https://forgemia.inra.fr/ue-apc/librairies/python/deepvisiontools_v1
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.11.9
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: <=3.12.12,>=3.11.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: torch==2.4.0
-Requires-Dist: torchvision==0.19.0
+Requires-Dist: torch<=2.6.0,>=2.4.0
+Requires-Dist: torchvision<=0.21.0,>=0.19.0
 Requires-Dist: pycocotools==2.0.8
-Requires-Dist: torchmetrics==1.4.0
-Requires-Dist: tensorboard==2.18.0
-Requires-Dist: ultralytics==8.3.28
-Requires-Dist: transformers==4.44.2
+Requires-Dist: torchmetrics<=1.7.0,>=1.4.0
+Requires-Dist: tensorboard<=2.19.0,>=2.18.0
+Requires-Dist: ultralytics<=8.3.95,>=8.3.28
+Requires-Dist: transformers<=4.50.0,>=4.44.2
 Requires-Dist: colorcet==3.1.0
-Requires-Dist: segmentation-models-pytorch==0.3.4
+Requires-Dist: segmentation-models-pytorch<=0.5.0,>0.4.0
+Requires-Dist: openpyxl==3.1.5
+Dynamic: license-file
 
 <!--
 <p align="center">
@@ -704,20 +707,22 @@ deepvisiontools is developped by INRAE (french National Research Institute for A
 
 ## Citations
 
-deepvisiontools provide models wrapper that allow you to use differents models with all machinery available. It is the resposability of the user to cite properly the actual model developpers.
+deepvisiontools provides model wrappers that allow you to use differents models with all machinery available. It is the responsability of the user to cite properly the actual model developpers.
 In particular, if using one of these models : Yolo, SMP please cite the actual models developpers (which are not deepvisiontools). For instance for Yolo, please cite ultralytics (https://www.ultralytics.com/) or for SMP cite https://github.com/qubvel-org/segmentation_models.pytorch  
 Similar stands for other models.
+TimmYolo model is a new model that combines timm encoders with a Yolo detection head. The strategy is based on patchification for the backbone (to avoid loosing resolution in resizing) then merge the features before running a Yolo detection heads. If you use this wrapper please cite both timm library, ultralytics library as well as deepvisiontools as model developper.
 
 ## Documentation
 
 All documentation about deepvisiontools, including tutorials, can be found at : https://deepvisiontools.readthedocs.io/en/latest/
 
 ## Installation
+We have tested deepvisiontools for python versions between 3.11.9 and 3.12.11, we recommend to use python 3.12.11 to minimize the risk of bugs.
 
 ```shell
 pip install deepvisiontools
 ```
-
+If you wish to use TimmYolo model, you may encounter an error saying that feature_only is not available for a given encoder name. Please upgrade your timm version (1.0.15 should have most of them). You may need to reinstall deepvisiontools as you could create conflicts with segmentation-models-pytorch.
 ## License
 
 GNU Affero General Public License v3 or later (AGPLv3+) (AGPL-3.0).

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/README.md

@@ -17,20 +17,22 @@ deepvisiontools is developped by INRAE (french National Research Institute for A
 
 ## Citations
 
-deepvisiontools provide models wrapper that allow you to use differents models with all machinery available. It is the resposability of the user to cite properly the actual model developpers.
+deepvisiontools provides model wrappers that allow you to use differents models with all machinery available. It is the responsability of the user to cite properly the actual model developpers.
 In particular, if using one of these models : Yolo, SMP please cite the actual models developpers (which are not deepvisiontools). For instance for Yolo, please cite ultralytics (https://www.ultralytics.com/) or for SMP cite https://github.com/qubvel-org/segmentation_models.pytorch  
 Similar stands for other models.
+TimmYolo model is a new model that combines timm encoders with a Yolo detection head. The strategy is based on patchification for the backbone (to avoid loosing resolution in resizing) then merge the features before running a Yolo detection heads. If you use this wrapper please cite both timm library, ultralytics library as well as deepvisiontools as model developper.
 
 ## Documentation
 
 All documentation about deepvisiontools, including tutorials, can be found at : https://deepvisiontools.readthedocs.io/en/latest/
 
 ## Installation
+We have tested deepvisiontools for python versions between 3.11.9 and 3.12.11, we recommend to use python 3.12.11 to minimize the risk of bugs.
 
 ```shell
 pip install deepvisiontools
 ```
-
+If you wish to use TimmYolo model, you may encounter an error saying that feature_only is not available for a given encoder name. Please upgrade your timm version (1.0.15 should have most of them). You may need to reinstall deepvisiontools as you could create conflicts with segmentation-models-pytorch.
 ## License
 
 GNU Affero General Public License v3 or later (AGPLv3+) (AGPL-3.0).

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/pyproject.toml

@@ -7,28 +7,32 @@ name = "deepvisiontools"
 authors = [
   { name = "Lucas Bernigaud Samatan", email = "lucas.bernigaud-samatan@inrae.fr" },
   { name = "Jordan Bernigaud Samatan", email = "jordan.bernigaud-samatan@inrae.fr" },
+  { name = "Paul Faucher", email = "paul.faucher@inrae.fr" },
 ]
 maintainers = [
   { name = "Jordan Bernigaud Samatan", email = "jordan.bernigaud-samatan@inrae.fr" },
+  { name = "Lucas Bernigaud Samatan", email = "lucas.bernigaud-samatan@inrae.fr" },
 ]
-description = "Overlay of PyTorch to generalize trainning and inference processes for detection & instance segmentation tasks."
+description = "Overlay of PyTorch to generalize trainning and inference processes for detection, instance segmentation and semantic segmentation tasks."
 readme = "README.md"
 classifiers = [
-  "Development Status :: 3 - Alpha",
+  "Development Status :: 4 - Beta",
   "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12"
 ]
 dynamic = ["version"]
-requires-python = ">=3.11.9"
+requires-python = ">=3.11.9,<=3.12.12"
 dependencies = [
-  "torch==2.4.0",
-  "torchvision==0.19.0",
+  "torch>=2.4.0,<=2.6.0",
+  "torchvision>=0.19.0,<=0.21.0",
   "pycocotools==2.0.8",
-  "torchmetrics==1.4.0",
-  "tensorboard==2.18.0",
-  "ultralytics==8.3.28",
-  "transformers==4.44.2",
+  "torchmetrics>=1.4.0,<=1.7.0",
+  "tensorboard>=2.18.0,<=2.19.0",
+  "ultralytics>=8.3.28,<=8.3.95",
+  "transformers>=4.44.2,<=4.50.0",
   "colorcet==3.1.0",
-  "segmentation-models-pytorch==0.3.4"
+  "segmentation-models-pytorch>0.4.0,<=0.5.0",
+  "openpyxl==3.1.5"
 ]
 
 license = { file = "LICENSE.txt" }

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/__init__.py

@@ -3,8 +3,9 @@ from deepvisiontools.train.trainer import Trainer
 from deepvisiontools.data.dataset import DeepVisionDataset, DeepVisionLoader
 from deepvisiontools.utils import visualization
 from deepvisiontools.inference.predictor import Predictor
+from deepvisiontools.inference.evaluator import Evaluator
 
-__version__ = "0.0.4"
+__version__ = "0.2.0"
 
 __all__ = (
     Configuration,
@@ -13,4 +14,5 @@ __all__ = (
     DeepVisionLoader,
     visualization,
     Predictor,
+    Evaluator,
 )

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/config/config.py

@@ -105,6 +105,7 @@ class Configuration(metaclass=_SingletonConfig):
         patchifier_mode: Literal["bbox", "instance_mask"] = "bbox",
         seed: Union[False, int] = False,
         deterministic: bool = False,
+        optimize=True,
     ):
 
         # generic
@@ -127,6 +128,8 @@ class Configuration(metaclass=_SingletonConfig):
         # reproducibility
         self.seed = seed
         self.deterministic = deterministic
+        # mixed precision (torch.amp + gradiant scaler)
+        self.optimize = optimize
 
     @property
     def device(self):

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/data/dataset.py

@@ -191,19 +191,21 @@ class DeepVisionDataset(Dataset):
             dataset3._indexes = idx[stop2:]
         return dataset1, dataset2, dataset3
 
-    def keep_indexes(self, indexes: Union[list, slice, Tensor]):
+    def keep_indexes(self, indexes: Union[list, slice, Tensor]) -> DeepVisionDataset:
         """Filter dataset by keeping only indices given in arg.
 
         Args:
             indexes (``Union[list, slice, Tensor]``): can be slice, Tensor or list. To use slice please use : slice(i, j) with i, j desired slice indexes in arg.
         """
+        dataset = copy.deepcopy(self)
         if isinstance(indexes, Tensor):
             assert (
                 indexes.dim() == 1
             ), f"Must use Tensor of dim 1 for indexes, got {indexes.shape}"
             indexes = indexes.tolist()
-        indx = torch.tensor(self._indexes)[indexes].tolist()
-        self._indexes = indx
+        indx = torch.tensor(dataset._indexes)[indexes].tolist()
+        dataset._indexes = indx
+        return dataset
 
     def export_dataset(
         self,

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/formats/base_data.py

@@ -144,7 +144,13 @@ class SemanticMaskData(BaseData):
             mask = Mask(mask[0])
         self._value = copy.deepcopy(mask)  # convert to long
         self._canvas_size = (mask.shape[-2], mask.shape[-1])
-        self._nb_object = torch.unique(mask).shape[0] - 1
+        # compute nb of objects (unique cls ids) in mask that are not background (i.e 0)
+        nb_object = (
+            torch.unique(mask).shape[0] - 1
+            if 0 in torch.unique(mask).tolist()
+            else torch.unique(mask).shape[0]
+        )
+        self._nb_object = nb_object
         self._device = Configuration().device
         # we use here a trick : handling scores operation is complicated at format level.
         # We dynamically will modify it in the operationhandler class and implement the modification here

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/formats/base_formats.py

@@ -190,8 +190,13 @@ class BaseSemanticFormat(BaseFormat):
                 scores.shape[-2:] == data.value.shape[-2:]
             ), f"scores do not have the same shape as data.value, got {scores.shape} and {data.value.shape}"
         self._data = data
-        # labels are derived from semantic mask data value
-        self._labels: Tensor = data.value.unique()[1:].long()
+        # labels are derived from semantic mask data value (careful : need to handle the case where 0 is not present in mask ...)
+        labs = (
+            data.value.unique()[1:].long()
+            if 0 in data.value.unique().tolist()
+            else data.value.unique().long()
+        )
+        self._labels: Tensor = labs
         # Check score
         if scores != None:
             scores = (

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/inference/__init__.py

@@ -1,4 +1,5 @@
 from deepvisiontools.inference.patchifier import BasePatchifier, SemanticPatchifier, DetectPatchifier, PostProcesser
 from deepvisiontools.inference.predictor import Predictor, PredictorDataLoader
+from deepvisiontools.inference.evaluator import Evaluator
 
-__all__ = ("Predictor", "BasePatchifier", "DetectPatchifier", "SemanticPatchifier", "PostProcesser", "PredictorDataLoader")
+__all__ = ("Predictor", "BasePatchifier", "DetectPatchifier", "SemanticPatchifier", "PostProcesser", "PredictorDataLoader", "Evaluator")

deepvisiontools-0.2.0/src/deepvisiontools/inference/evaluator.py

@@ -0,0 +1,256 @@
+from deepvisiontools import DeepVisionDataset, Configuration
+from deepvisiontools.inference import Predictor
+from deepvisiontools.utils import visualization
+from tqdm import tqdm
+from pathlib import Path
+import pandas as pd
+from typing import Literal, Union
+from openpyxl import load_workbook
+from openpyxl.styles import Font, PatternFill
+import random
+
+
+class Evaluator:
+    """Evaluator class : evaluate a given Predictor (model + patch_size + additional Configurations) on a dataset with given metrics.
+    The results are saved in a generated csv file (metrics at dataset level) and in a xlsx file (metrics at dataset and sample levels).
+    Highlighting samples that deviate from the mean or median (giving deviation_method) by nb_sigma sigma in the xlsx file.
+    Create visualizations of predictions giving number_visu.
+    Returns the dictionnary with metrics at dataset level and the dictionnary with metrics at sample level.
+    Prints a dataframe with metrics at dataset level (same content as in the generated csv file).
+
+    Args:
+        predictor (``Predictor``): Predictor class to evaluate
+        metrics (``list``): List of metrics to evaluate the Predictor on
+        deviation_method (``Literal["mean", "median"]``, **optional**): method to compute outlayers. Defaults to "mean".
+        nb_sigma (``Union[int, float]``, **optional**): number of standard deviations for outlayers. Defaults to 2.
+
+    Example:
+    ----------
+
+    .. highlight:: python
+    .. code-block:: python
+
+        >>> from deepvisiontools import Evaluator, Predictor
+        >>> from deepvisiontools.metrics import DetectF1Score
+        >>> predictor = Predictor(model=\path\to\model.pth)
+        >>> evaluator = Evaluator(predictor, metrics=[DetectF1Score()])
+        >>> evaluator.evaluate(mydataset, "results")
+
+    Attributes
+    ----------
+
+    Attributes:
+        predictor (``Predictor``)
+        metrics (``List[BaseMetric]``)
+        nb_sigma (``int``)
+        data_type (``Literal["instance_mask", "bbox", "keypoint", "semantic_mask"]``)
+        deviation_method (```Literal["mean", "median"]``)
+
+
+    **Methods**
+
+    """
+
+    def __init__(
+        self,
+        predictor: Predictor,
+        metrics: list,
+        deviation_method: Literal["mean", "median"] = "mean",
+        nb_sigma: Union[int, float] = 2,
+    ):
+
+        self.predictor = predictor
+        self.metrics = metrics
+        self.nb_sigma = nb_sigma
+        self.data_type = Configuration().data_type
+        self.deviation_method = deviation_method
+        assert deviation_method in [
+            "mean",
+            "median",
+        ], "deviation_method must be 'mean' or 'median'"
+
+    def evaluate(
+        self,
+        dataset: DeepVisionDataset,
+        result_folder: Union[str, Path],
+        number_visu: Union[Literal["all"], int] = "all",
+    ):
+        """Run evaluation on dataset. Compute metrics for dataset and for each sample of the dataset."""
+        result_folder = (
+            result_folder if isinstance(result_folder, Path) else Path(result_folder)
+        )
+        result_folder.mkdir(parents=True, exist_ok=True)
+        export_csv_path = result_folder / "results.csv"
+        export_xlsx_path = result_folder / "results.xlsx"
+        visu_folder_path = result_folder / "visu"
+
+        assert (
+            isinstance(number_visu, int) or number_visu == "all"
+        ), "number_visu must be integer or equal to 'all'"
+
+        dataset.preprocessing = None  # because already preprocess in Predictor
+
+        # Creation and initialisation of the dictionary containing the metrics for each image (one dictionary/metric containing one dictionary/image)
+        metric_sample_dict = {}
+        for metric in self.metrics:
+            metric.to(Configuration().device)
+            metric_sample_dict.update({metric.name: {}})
+
+        if (
+            number_visu != 0 and number_visu != "all"
+        ):  # randomly select index of the number_visu images to visualize
+            list_index_img = [i for i in range(len(dataset))]
+            random.shuffle(list_index_img)
+            list_index_img_visu = list_index_img[:number_visu]
+
+        # For each sample in the dataset : prediction then calculation and storage of tp, fp, tn, fn (for each metric)
+        iterator = tqdm(dataset, total=len(dataset), desc=f"Evaluation progress ")
+
+        for index_img, (image, target, img_name) in enumerate(iterator):
+            prediction = self.predictor.predict(image)
+
+            for metric in self.metrics:
+                metric.update(
+                    prediction, target
+                )  # update 'stats' attribute for each metric
+
+                metric_sample_dict[metric.name].update(
+                    {img_name: {"img_index_in_dataset": index_img}}
+                )  # creation of the image dictionary (for the given metric) with its index information
+                # compute metric for the image (all classes combined and for each class)
+                metric_sample = metric.compute_last_sample()
+                metric_sample_dict[metric.name][img_name].update(metric_sample)
+
+            # prediction visualization
+            if number_visu != 0 and number_visu != "all":
+                if index_img in list_index_img_visu:
+                    visualization(
+                        image,
+                        prediction,
+                        save_path=visu_folder_path
+                        / "visu_img{0}_{1}".format(index_img, img_name),
+                    )
+            elif number_visu == "all":
+                visualization(
+                    image,
+                    prediction,
+                    save_path=visu_folder_path
+                    / "visu_img{0}_{1}".format(index_img, img_name),
+                )
+
+        # after all updates recompute to get averaged values of metric (global, samplewise, macro, micro), save in metric_dict
+        metric_dict = {}
+        for metric in self.metrics:
+            results = metric.compute()
+            metric_dict.update({metric.name: results})
+
+        # Converts dictionary metric values from tensor to float :
+        for metric_name in metric_dict:
+            for sous_metric_name in metric_dict[metric_name]:
+                metric_dict[metric_name][sous_metric_name] = round(
+                    metric_dict[metric_name][sous_metric_name].item(), 3
+                )
+
+        # Converts the dict into a dataframe, which is saved in a csv file:
+        df_metrics = pd.DataFrame(metric_dict)
+        df_metrics.to_csv(export_csv_path)
+
+        # Create the Excel file with metrics values for each image
+        sheet_names = self._create_xls(export_xlsx_path, df_metrics, metric_sample_dict)
+
+        # Modifies the Excel file with metrics : highlights extreme values and adds mean, std, median
+        self._formate_xls(export_xlsx_path, sheet_names, metric_sample_dict)
+
+        print(df_metrics)
+        return (metric_dict, metric_sample_dict)
+
+    def _create_xls(self, export_xlsx_path, df_metrics, metric_sample_dict):
+        """Create an Excel file with metrics values for each image"""
+        sheet_names = []
+        with pd.ExcelWriter(export_xlsx_path) as writer:
+            df_metrics.to_excel(
+                writer, sheet_name="Dataset_Metrics", index=True
+            )  # creates a first sheet with the 'sub-metrics' for each metric (equivalent to the contents of the csv generated earlier)
+            for metric in metric_sample_dict:
+                df_sample = pd.DataFrame(metric_sample_dict[metric]).T
+                df_sample["Outlier?"] = None
+                sheet_name = "{0}_by_samples".format(metric)
+                if len(sheet_name) > 31:  # the length of excel sheets name is 31
+                    sheet_name = sheet_name[: len(sheet_name) - (len(sheet_name) - 31)]
+                df_sample.to_excel(
+                    writer, sheet_name=sheet_name, index=True
+                )  # creates a sheet by metric with details by image
+                sheet_names.append(sheet_name)
+        return sheet_names
+
+    def _highlight_cells(self, sheet, colonne_verif, min_val, max_val):
+        """Applies a red background and bold text if the value is outside the range"""
+        # Style for formatting (red fill + bold text)
+        red_fill = PatternFill(
+            start_color="FFC7CE", end_color="FFC7CE", fill_type="solid"
+        )
+        bold_font = Font(bold=True, color="9C0006")
+
+        for row in sheet.iter_rows(
+            min_row=2, min_col=colonne_verif, max_col=colonne_verif
+        ):
+            for cell in row:
+                if cell.value is not None and (
+                    cell.value < min_val or cell.value > max_val
+                ):
+                    cell.fill = red_fill
+                    sheet.cell(row=cell.row, column=1).font = (
+                        bold_font  # Make the index bold and red
+                    )
+                    sheet.cell(cell.row, sheet.max_column).value = (
+                        "True"  # True in "Outlier?" column
+                    )
+
+    def _formate_xls(self, export_xlsx_path, sheet_names, metric_sample_dict):
+        """Modifies the Excel file with metrics : highlights extreme values and adds mean, std, median"""
+
+        wb = load_workbook(export_xlsx_path)
+
+        for sh_name, metric in zip(sheet_names, metric_sample_dict):
+
+            df_sample = pd.DataFrame(metric_sample_dict[metric]).T
+            columns_list = df_sample.columns.tolist()
+            sheet_maw_row = wb[sh_name].max_row
+
+            # add mean, std, median labels in last rows
+            wb[sh_name].cell(sheet_maw_row + 2, 1).value = "Mean : "
+            wb[sh_name].cell(sheet_maw_row + 3, 1).value = "Std : "
+            wb[sh_name].cell(sheet_maw_row + 4, 1).value = "Median : "
+
+            # add mean, std and median values in last rows for each class and "all_class"
+            for num_col, col_name in enumerate(columns_list[1:]):
+                mean = df_sample.mean()[col_name]
+                std = df_sample.std()[col_name]
+                median = df_sample.median()[col_name]
+
+                num_col_xsl = num_col + 3
+                # highlights extreme values
+                if self.deviation_method == "median":
+                    self._highlight_cells(
+                        wb[sh_name],
+                        colonne_verif=num_col_xsl,
+                        min_val=median - (self.nb_sigma * std),
+                        max_val=median + (self.nb_sigma * std),
+                    )
+                else:
+                    self._highlight_cells(
+                        wb[sh_name],
+                        colonne_verif=num_col_xsl,
+                        min_val=mean - (self.nb_sigma * std),
+                        max_val=mean + (self.nb_sigma * std),
+                    )
+
+                # add mean, std and median in last rows
+                wb[sh_name].cell(sheet_maw_row + 2, num_col_xsl).value = round(mean, 3)
+                wb[sh_name].cell(sheet_maw_row + 3, num_col_xsl).value = round(std, 3)
+                wb[sh_name].cell(sheet_maw_row + 4, num_col_xsl).value = round(
+                    median, 3
+                )
+
+        # Save file after modifications
+        wb.save(export_xlsx_path)

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/inference/predictor.py

@@ -16,6 +16,7 @@ from deepvisiontools.inference.patchifier import (
 )
 from torchvision.transforms.v2 import Pad, CenterCrop
 from tqdm import tqdm
+from deepvisiontools.formats import SemanticMaskData, SemanticMaskFormat
 
 
 def build_patchifier(*args, **kwargs):
@@ -39,7 +40,8 @@ class Predictor:
         nms_iou_threshold (``float``, **optional**): nms threshold to be used when upatchifying. Defaults to 0.45.
         final_score_threshold (``float``, **optional**): Apply a score thresholding after penalty and after nms. Defaults to 0.4.
         categories (``Dict[int, str]``, **optional**): To rename your categories in the visualization.
-        patchifier (``Union[BasePatchifier, None], **optional``): If None use default SemanticPatchifier or DetectPatchifier according to Configuration().data_type. Default to None.
+        patchifier (``Union[BasePatchifier, None], **optional**): If None use default SemanticPatchifier or DetectPatchifier according to Configuration().data_type. Default to None.
+        verbose (``bool``, **optional**) : if set to True will display progress state in patchs predictions. Default to True.
 
     Example:
     ----------
@@ -64,6 +66,7 @@ class Predictor:
         cropper (``Transform``)
         patchifier (``BasePatchifier``)
         categories (``Dict[int, str]``)
+        verbose (``bool``)
 
 
     **Methods**
@@ -79,6 +82,7 @@ class Predictor:
         batch_size: int = 1,
         categories: Dict[int, str] = None,
         patchifier: Union[BasePatchifier, None] = None,
+        verbose: bool = True,
     ):
         assert any(
             [
@@ -103,24 +107,36 @@ class Predictor:
         else:
             self.patchifier = patchifier
         self.categories = categories
+        self.verbose = verbose
 
     def forward_pass(self, batch_patchs: Tensor) -> BatchedFormat:
         """Run predictions on image / batch of patches"""
         with torch.no_grad():
             loader = PredictorDataLoader(batch_patchs, self.batch_size)
             # wrap in tqdm if more than one batch
-            loader = (
-                tqdm(loader, desc="Predict on batch of patches : ", total=len(loader))
-                if len(loader) > 1
-                else loader
-            )
+            if self.verbose:
+                loader = (
+                    tqdm(
+                        loader, desc="Predict on batch of patches : ", total=len(loader)
+                    )
+                    if len(loader) > 1
+                    else loader
+                )
             predictions = BatchedFormat([])
+
             for patch in loader:
-                predictions += self.model.get_predictions(patch)
+                with torch.autocast(
+                    device_type=Configuration().device,
+                    dtype=torch.float16,
+                    enabled=Configuration().optimize,
+                ):
+                    predictions += self.model.get_predictions(patch)
         return predictions
 
     def predict(
-        self, image: Union[str, Path, Tensor], visu_path: Union[str, Path] = ""
+        self,
+        image: Union[str, Path, Tensor],
+        visu_path: Union[str, Path] = "",
     ) -> BaseFormat:
         """Main function of ```Predictor``` : call everything needed for prediction.
 
@@ -143,12 +159,33 @@ class Predictor:
         h_original, w_original = image.shape[-2:]
         image = image.to(Configuration().device)
         # preprocess
-        preprocessed_image = self.preprocessing(image[None, :])[0]
+        if self.preprocessing != None:
+            preprocessed_image = self.preprocessing(image[None, :])[0]
+        else:
+            preprocessed_image = image
         # handles patch if needed
         if self.patch_size != None and self.patch_size != (
             image.shape[-2],
             image.shape[-1],
         ):
+            _h_pad, _w_pad = 0, 0
+            if image.shape[-2] < self.patch_size[0]:
+                _h_pad = self.patch_size[0] - image.shape[-2]
+                _t_pad = int(_h_pad // 2)
+                _t_pad = _t_pad if _t_pad > 0 else 0
+                _b_pad = _h_pad - _t_pad
+                _b_pad = _b_pad if _b_pad > 0 else 0
+            if image.shape[-2] < self.patch_size[0]:
+                _w_pad = self.patch_size[1] - image.shape[-1]
+                _l_pad = int(_w_pad // 2)
+                _l_pad = _l_pad if _l_pad > 0 else 0
+                _r_pad = _w_pad - _l_pad
+                _r_pad = _r_pad if _r_pad > 0 else 0
+            if _h_pad > 0 or _w_pad > 0:
+                preprocessed_image = Pad((_l_pad, _t_pad, _r_pad, _b_pad))(
+                    preprocessed_image
+                )
+
             batch_patch, pad_origins, padded_image, pad_coord = (
                 self.patchifier.patchify(preprocessed_image)
             )

{deepvisiontools-0.0.4 → deepvisiontools-0.2.0}/src/deepvisiontools/metrics/available_metrics.py

@@ -118,7 +118,7 @@ class ClassifRecall(ClassifMetric):
         super().__init__(func=F.recall, name="ClassifRecall", *args, **kwargs)
 
 
-class ClassifAccuracy(ClassifMetric):
+class ClassifPrecision(ClassifMetric):
     """Classification precision score"""
 
     def __init__(self, *args, **kwargs):