deepvisiontools 0.1.0__tar.gz → 0.2.0__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: deepvisiontools
-Version: 0.1.0
+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>
+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
         
@@ -673,7 +673,7 @@ Project-URL: Repository, https://forgemia.inra.fr/ue-apc/librairies/python/deepv
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: <=3.12.9,>=3.11.9
+Requires-Python: <=3.12.12,>=3.11.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: torch<=2.6.0,>=2.4.0
@@ -684,7 +684,7 @@ 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.4.0,>=0.3.4
+Requires-Dist: segmentation-models-pytorch<=0.5.0,>0.4.0
 Requires-Dist: openpyxl==3.1.5
 Dynamic: license-file
 
@@ -707,21 +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.9
+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.1.0 → deepvisiontools-0.2.0}/README.md

@@ -17,21 +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.9
+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.1.0 → deepvisiontools-0.2.0}/pyproject.toml

@@ -11,6 +11,7 @@ authors = [
 ]
 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 and semantic segmentation tasks."
 readme = "README.md"
@@ -20,7 +21,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12"
 ]
 dynamic = ["version"]
-requires-python = ">=3.11.9,<=3.12.9"
+requires-python = ">=3.11.9,<=3.12.12"
 dependencies = [
   "torch>=2.4.0,<=2.6.0",
   "torchvision>=0.19.0,<=0.21.0",
@@ -30,7 +31,7 @@ dependencies = [
   "ultralytics>=8.3.28,<=8.3.95",
   "transformers>=4.44.2,<=4.50.0",
   "colorcet==3.1.0",
-  "segmentation-models-pytorch>=0.3.4,<=0.4.0",
+  "segmentation-models-pytorch>0.4.0,<=0.5.0",
   "openpyxl==3.1.5"
 ]
 

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

@@ -5,7 +5,7 @@ from deepvisiontools.utils import visualization
 from deepvisiontools.inference.predictor import Predictor
 from deepvisiontools.inference.evaluator import Evaluator
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 __all__ = (
     Configuration,

{deepvisiontools-0.1.0 → 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.1.0 → deepvisiontools-0.2.0}/src/deepvisiontools/inference/predictor.py

@@ -123,8 +123,14 @@ class Predictor:
                     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(

{deepvisiontools-0.1.0 → deepvisiontools-0.2.0}/src/deepvisiontools/metrics/base_metric.py

@@ -38,7 +38,7 @@ class DetectMetric(Metric):
         self.func = func
         self.name = name
         self.add_state("stats", default=[], dist_reduce_fx="cat")
-        self.nc = 1 # always one class
+        self.nc = 1  # always one class
 
     def update(
         self,
@@ -71,67 +71,79 @@ class DetectMetric(Metric):
                 tp, fp, fn, _ = matcher.match_pred_target(pred, targ)
             elif pred.nb_object != 0 and targ.nb_object == 0:
                 tp, fp, fn, _ = 0, pred.nb_object, 0, None
-            #elif prediction.size == 0 and target.size != 0:
+            # elif prediction.size == 0 and target.size != 0:
             elif pred.nb_object == 0 and targ.nb_object != 0:
                 tp, fp, fn, _ = 0, 0, targ.nb_object, None
             else:
                 tp, fp, fn, _ = torch.nan, torch.nan, torch.nan, None
 
             # NaN because of no tn in detection
-            self.stats.append(torch.tensor([[[tp, fp, torch.nan, fn, torch.nan]]])) # fix tn and support to nan
-    
+            self.stats.append(
+                torch.tensor([[[tp, fp, torch.nan, fn, torch.nan]]])
+            )  # fix tn and support to nan
+
     def global_micro_compute(self) -> Tensor:
         """Compute metric with global/micro averagging."""
         n_samples = len(self.stats)
         samples_stack = torch.cat(self.stats).view(n_samples, self.nc, 5)  # (N, NC, 5)
         # sum stats accross samples
-        samples_stack = samples_stack.sum(dim=0)  # (NC, 5)
+        samples_stack = samples_stack.nansum(dim=0)  # (NC, 5)
         # sum stats accross classes
-        micro_stack = torch.sum(samples_stack, dim=0)  # (5,)
+        micro_stack = torch.nansum(samples_stack, dim=0)  # (5,)
         # compute metric
         tp, fp, tn, fn, _ = micro_stack.unbind(0)
         return self.func(tp, fp, tn, fn)
-    
+
     def samplewise_micro(self) -> Tensor:
         """Compute metric with samplewise/micro averagging."""
         n_samples = len(self.stats)
         samples_stack = torch.cat(self.stats).view(n_samples, self.nc, 5)  # (N, NC, 5))
         # sum stat accross classes
-        samples_stack = samples_stack.sum(dim=1)  # (NC, 5)
+        samples_stack = samples_stack.nansum(dim=1)  # (NC, 5)
         # compute metric/sample
         tp, fp, tn, fn, _ = samples_stack.unbind(dim=1)
         samples_metrics = self.func(tp, fp, tn, fn)
         # mean accross samples
         return torch.nanmean(samples_metrics)
-    
+
     def compute_last_sample(self):
         """Return metrics values of the last sample in self.stats.
             Used in combination with self.update
-        
+
         Returns:
              Dict[str, Float]: dictionnary with metric value for all classes combined and for each class
         """
 
         if not self.stats:
-            return {'all_cls': torch.tensor(torch.nan)}
-        
+            return {"all_cls": torch.tensor(torch.nan)}
+
         metric_sample_dict = {}
 
-        matrix_stats_img = self.stats[-1].squeeze(0)   # matrix with stats (tp, fp, tn, fn) of one sample (one row for each class)
+        matrix_stats_img = self.stats[-1].squeeze(
+            0
+        )  # matrix with stats (tp, fp, tn, fn) of one sample (one row for each class)
         nb_class = matrix_stats_img.size(dim=0)
-        tp, fp, tn, fn, _ = matrix_stats_img.nansum(dim=0).unbind(dim=0)   # sum over all classes
-        all_class_metric_value = round(self.func(tp, fp, tn, fn).item(),3)    # metric compute for all classes
-        metric_sample_dict['all_cls'] = all_class_metric_value
+        tp, fp, tn, fn, _ = matrix_stats_img.nansum(dim=0).unbind(
+            dim=0
+        )  # sum over all classes
+        all_class_metric_value = round(
+            self.func(tp, fp, tn, fn).item(), 3
+        )  # metric compute for all classes
+        metric_sample_dict["all_cls"] = all_class_metric_value
 
         if nb_class > 1:
-            for index_class in range (nb_class) :   # metric compute for each class
-                matrix_stats_img_class = matrix_stats_img[index_class,:]
-                tp, fp, tn, fn, _ = matrix_stats_img_class.unbind(dim=0)    # stats (tp, fp, tn, fn) of the given class
-                class_metric_value = round(self.func(tp, fp, tn, fn).item(),3)    # metric compute for the given class
+            for index_class in range(nb_class):  # metric compute for each class
+                matrix_stats_img_class = matrix_stats_img[index_class, :]
+                tp, fp, tn, fn, _ = matrix_stats_img_class.unbind(
+                    dim=0
+                )  # stats (tp, fp, tn, fn) of the given class
+                class_metric_value = round(
+                    self.func(tp, fp, tn, fn).item(), 3
+                )  # metric compute for the given class
                 metric_sample_dict["cls_{0}".format(index_class)] = class_metric_value
 
         return metric_sample_dict
-    
+
     def compute(self) -> Dict[str, Tensor]:
         """Return metric computed with internal state.
 
@@ -140,7 +152,7 @@ class DetectMetric(Metric):
         """
         if not self.stats:
             return {self.name: torch.tensor(torch.nan)}
-        
+
         # global micro
         global_value = self.global_micro_compute()
         # samplewise micro
@@ -218,27 +230,31 @@ class ClassWiseDetectMetric(Metric):
             if i == 0:
                 met.update(prediction, target)
             else:
-                filtered_pred = self._filter_classes(prediction, i-1)   # -1 because classes start at 0
-                filtered_targ = self._filter_classes(target, i-1)
+                filtered_pred = self._filter_classes(
+                    prediction, i - 1
+                )  # -1 because classes start at 0
+                filtered_targ = self._filter_classes(target, i - 1)
                 met.update(filtered_pred, filtered_targ)
-            
+
             # retrieve and save in a list the stats for each sample in the batch for the given class
             batch_size = prediction.size
-            for num_elem in range (batch_size,0,-1):
+            for num_elem in range(batch_size, 0, -1):
                 met_samples_result.append(met.stats[-num_elem])
-            
-            list_met_class.append(met_samples_result)   # save the list in the list containing the list of each class
-        
+
+            list_met_class.append(
+                met_samples_result
+            )  # save the list in the list containing the list of each class
+
         # save the batch sample stats for each class in a matrix (N, NC, 5) and append in metric 'stats' attribute
         for num_sample in range(batch_size):
             sample_stats = []
-            for num_class in range(1,len(list_met_class)):
+            for num_class in range(1, len(list_met_class)):
                 sample_stats.append(list_met_class[num_class][num_sample])
-            
-            class_stack = torch.cat(sample_stats).view(1, Configuration().num_classes, 5)  # (N, NC, 5)
-            self.stats.append(class_stack)
-
 
+            class_stack = torch.cat(sample_stats).view(
+                1, Configuration().num_classes, 5
+            )  # (N, NC, 5)
+            self.stats.append(class_stack)
 
         # for sample_list_met_class in list_met_class:
         #     sample_list_met_class = sample_list_met_class[1:]
@@ -305,27 +321,37 @@ class ClassWiseDetectMetric(Metric):
     def compute_last_sample(self):
         """Return metrics values of the last sample in self.stats.
             Used in combination with self.update
-        
+
         Returns:
              Dict[str, Float]: dictionnary with metric value for all classes combined and for each class
         """
 
         if not self.stats:
-            return {'all_cls': torch.tensor(torch.nan)}
-        
+            return {"all_cls": torch.tensor(torch.nan)}
+
         metric_sample_dict = {}
 
-        matrix_stats_img = self.stats[-1].squeeze(0)   # matrix with stats (tp, fp, tn, fn) of one sample (one row for each class)
+        matrix_stats_img = self.stats[-1].squeeze(
+            0
+        )  # matrix with stats (tp, fp, tn, fn) of one sample (one row for each class)
         nb_class = matrix_stats_img.size(dim=0)
-        tp, fp, tn, fn, _ = matrix_stats_img.nansum(dim=0).unbind(dim=0)   # sum over all classes
-        all_class_metric_value = round(self.func(tp, fp, tn, fn).item(),3)    # metric compute for all classes
-        metric_sample_dict['all_cls'] = all_class_metric_value
+        tp, fp, tn, fn, _ = matrix_stats_img.nansum(dim=0).unbind(
+            dim=0
+        )  # sum over all classes
+        all_class_metric_value = round(
+            self.func(tp, fp, tn, fn).item(), 3
+        )  # metric compute for all classes
+        metric_sample_dict["all_cls"] = all_class_metric_value
 
         if nb_class > 1:
-            for index_class in range (nb_class) :   # metric compute for each class
-                matrix_stats_img_class = matrix_stats_img[index_class,:]
-                tp, fp, tn, fn, _ = matrix_stats_img_class.unbind(dim=0)    # stats (tp, fp, tn, fn) of the given class
-                class_metric_value = round(self.func(tp, fp, tn, fn).item(),3)    # metric compute for the given class
+            for index_class in range(nb_class):  # metric compute for each class
+                matrix_stats_img_class = matrix_stats_img[index_class, :]
+                tp, fp, tn, fn, _ = matrix_stats_img_class.unbind(
+                    dim=0
+                )  # stats (tp, fp, tn, fn) of the given class
+                class_metric_value = round(
+                    self.func(tp, fp, tn, fn).item(), 3
+                )  # metric compute for the given class
                 metric_sample_dict["cls_{0}".format(index_class)] = class_metric_value
 
         return metric_sample_dict
@@ -336,9 +362,9 @@ class ClassWiseDetectMetric(Metric):
         Returns:
              Dict[str, Tensor]: dictionnary with all "global" DetectMetric in self.classmetrics
         """
-        #classwisedict = {met.name: met.compute()["global"] for met in self.classmetrics}
-        #return classwisedict
-        
+        # classwisedict = {met.name: met.compute()["global"] for met in self.classmetrics}
+        # return classwisedict
+
         if not self.stats:
             return {self.name: torch.tensor(torch.nan)}
 
@@ -349,8 +375,7 @@ class ClassWiseDetectMetric(Metric):
         # global macro
         global_macro, class_metrics = self.global_macro_compute()
         classes_dict = {
-            f"/cls_{i}": class_metrics[i]
-            for i in range(class_metrics.nelement())
+            f"/cls_{i}": class_metrics[i] for i in range(class_metrics.nelement())
         }
         metric_dict.update({"_global_macro": global_macro})
         metric_dict.update(classes_dict)
@@ -460,9 +485,9 @@ class ClassifMetric(Metric):
         n_samples = len(self.stats)
         samples_stack = torch.cat(self.stats).view(n_samples, self.nc, 5)  # (N, NC, 5)
         # sum stats accross samples
-        samples_stack = samples_stack.sum(dim=0)  # (NC, 5)
+        samples_stack = samples_stack.nansum(dim=0)  # (NC, 5)
         # sum stats accross classes
-        micro_stack = torch.sum(samples_stack, dim=0)  # (5,)
+        micro_stack = torch.nansum(samples_stack, dim=0)  # (5,)
         # compute metric
         tp, fp, tn, fn, _ = micro_stack.unbind(0)
         return self.func(tp, fp, tn, fn)
@@ -473,7 +498,7 @@ class ClassifMetric(Metric):
         n_samples = len(self.stats)
         samples_stack = torch.cat(self.stats).view(n_samples, self.nc, 5)  # (N, NC, 5)
         # sum stats accross samples
-        samples_stack = samples_stack.sum(dim=0)  # (NC, 5)
+        samples_stack = samples_stack.nansum(dim=0)  # (NC, 5)
         # compute metric/class
         tp, fp, tn, fn, _ = samples_stack.unbind(1)
         class_metrics = self.func(tp, fp, tn, fn)  # (NC,)
@@ -484,7 +509,7 @@ class ClassifMetric(Metric):
         n_samples = len(self.stats)
         samples_stack = torch.cat(self.stats).view(n_samples, self.nc, 5)  # (N, NC, 5))
         # sum stat accross classes
-        samples_stack = samples_stack.sum(dim=1)  # (NC, 5)
+        samples_stack = samples_stack.nansum(dim=1)  # (NC, 5)
         # compute metric/sample
         tp, fp, tn, fn, _ = samples_stack.unbind(dim=1)
         samples_metrics = self.func(tp, fp, tn, fn)
@@ -504,35 +529,45 @@ class ClassifMetric(Metric):
         macro_samplewise = torch.nanmean(macro, dim=0)
 
         return macro_samplewise
-    
+
     def compute_last_sample(self):
         """Return metrics values of the last sample in self.stats.
             Used in combination with self.update
-        
+
         Returns:
              Dict[str, Float]: dictionnary with metric value for all classes combined and for each class
         """
 
         if not self.stats:
-            return {'all_cls': torch.tensor(torch.nan)}
-        
+            return {"all_cls": torch.tensor(torch.nan)}
+
         metric_sample_dict = {}
 
-        matrix_stats_img = self.stats[-1].squeeze(0)   # matrix with stats (tp, fp, tn, fn) of one sample (one row for each class)
+        matrix_stats_img = self.stats[-1].squeeze(
+            0
+        )  # matrix with stats (tp, fp, tn, fn) of one sample (one row for each class)
         nb_class = matrix_stats_img.size(dim=0)
-        tp, fp, tn, fn, _ = matrix_stats_img.nansum(dim=0).unbind(dim=0)   # sum over all classes
-        all_class_metric_value = round(self.func(tp, fp, tn, fn).item(),3)    # metric compute for all classes
-        metric_sample_dict['all_cls'] = all_class_metric_value
+        tp, fp, tn, fn, _ = matrix_stats_img.nansum(dim=0).unbind(
+            dim=0
+        )  # sum over all classes
+        all_class_metric_value = round(
+            self.func(tp, fp, tn, fn).item(), 3
+        )  # metric compute for all classes
+        metric_sample_dict["all_cls"] = all_class_metric_value
 
         if nb_class > 1:
-            for index_class in range (nb_class) :   # metric compute for each class
-                matrix_stats_img_class = matrix_stats_img[index_class,:]
-                tp, fp, tn, fn, _ = matrix_stats_img_class.unbind(dim=0)    # stats (tp, fp, tn, fn) of the given class
-                class_metric_value = round(self.func(tp, fp, tn, fn).item(),3)    # metric compute for the given class
+            for index_class in range(nb_class):  # metric compute for each class
+                matrix_stats_img_class = matrix_stats_img[index_class, :]
+                tp, fp, tn, fn, _ = matrix_stats_img_class.unbind(
+                    dim=0
+                )  # stats (tp, fp, tn, fn) of the given class
+                class_metric_value = round(
+                    self.func(tp, fp, tn, fn).item(), 3
+                )  # metric compute for the given class
                 metric_sample_dict["cls_{0}".format(index_class)] = class_metric_value
 
         return metric_sample_dict
-    
+
     def compute(self):
         """Comput metric with all averag strategy and return a dict with all values."""
         if not self.stats:

{deepvisiontools-0.1.0 → deepvisiontools-0.2.0}/src/deepvisiontools/models/__init__.py

@@ -1,13 +1,15 @@
-from deepvisiontools.models.yolov8.yolov8 import Yolov8
-from deepvisiontools.models.yolov8seg.yolov8seg import Yolov8Seg
+from deepvisiontools.models.yolo.yolo import Yolo
+from deepvisiontools.models.yoloseg.yoloseg import YoloSeg
 from deepvisiontools.models.mask2former.mask2former import Mask2Former
+from deepvisiontools.models.timmyolo.timmyolo import TimmYolo
 from deepvisiontools.models.basemodel import BaseModel
 from deepvisiontools.models.smp.smp import SMP, _ConcreteSegmentationModel
 
 __all__ = (
     "BaseModel",
-    "Yolov8",
-    "Yolov8Seg",
+    "Yolo",
+    "YoloSeg",
+    "TimmYolo",
     "Mask2Former",
     "SMP",
     "_ConcreteSegmentationModel",

deepvisiontools-0.2.0/src/deepvisiontools/models/timmyolo/__init__.py

@@ -0,0 +1,4 @@
+from deepvisiontools.models.timmyolo.timmyolo import TimmYolo, LossHyperParams, YoloLoss
+from deepvisiontools.models.timmyolo.errors import NonImplementedForward
+
+__all__ = ("TimmYolo", "LossHyperParams", "YoloLoss", "NonImplementedForward")

deepvisiontools-0.2.0/src/deepvisiontools/models/timmyolo/errors.py

@@ -0,0 +1,5 @@
+class NonImplementedForward(Exception):
+    def __init__(self):
+        super().__init__(
+            message="Model does not work with forward because of internal patchification and feature merging required. Please use model.run_forward() to perform predictions."
+        )