segmodels-keras 0.1.0.dev9__tar.gz → 0.1.0.dev10__tar.gz

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev9
+Version: 0.1.0.dev10
 Summary: Image segmentation models with pre-trained backbones with Keras.
 Home-page: https://github.com/orthoseg/segmodels_keras
 Author: Pieter Roggemans

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/pyproject.toml

@@ -1,3 +1,7 @@
+[[tool.mypy.overrides]]
+module = "h5py.*,keras.*,six.*,setuptools.*,sphinx_rtd_theme.*,tensorflow.*"
+ignore_missing_imports = true
+
 [tool.pyright]
 exclude = ["local_ignore", "**/node_modules", "**/__pycache__", "**/.*"]
 ignore = ["*"]

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/__init__.py

@@ -1,35 +1,37 @@
 import functools  # noqa: I001
 import os
+from typing import Any
+from collections.abc import Callable
 
 # __version__ should be defined as soon as possible
 from ._version import __version__
 
 from . import base
 
-_KERAS_FRAMEWORK_NAME = "keras"
-_TF_KERAS_FRAMEWORK_NAME = "tf.keras"
+_KERAS_FRAMEWORK_NAME: str = "keras"
+_TF_KERAS_FRAMEWORK_NAME: str = "tf.keras"
 
-_DEFAULT_KERAS_FRAMEWORK = _KERAS_FRAMEWORK_NAME
-_KERAS_FRAMEWORK = None
-_KERAS_BACKEND = None
-_KERAS_LAYERS = None
-_KERAS_MODELS = None
-_KERAS_UTILS = None
-_KERAS_LOSSES = None
+_DEFAULT_KERAS_FRAMEWORK: str = _KERAS_FRAMEWORK_NAME
+_KERAS_FRAMEWORK: str | None = None
+_KERAS_BACKEND: Any = None
+_KERAS_LAYERS: Any = None
+_KERAS_MODELS: Any = None
+_KERAS_UTILS: Any = None
+_KERAS_LOSSES: Any = None
 
 
-def inject_global_losses(func):
+def inject_global_losses(func: Callable[..., Any]) -> Callable[..., Any]:
     @functools.wraps(func)
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
         kwargs["losses"] = _KERAS_LOSSES
         return func(*args, **kwargs)
 
     return wrapper
 
 
-def filter_kwargs(func):
+def filter_kwargs(func: Callable[..., Any]) -> Callable[..., Any]:
     @functools.wraps(func)
-    def wrapper(*args, **kwargs):
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
         new_kwargs = {
             k: v
             for k, v in kwargs.items()
@@ -40,12 +42,12 @@ def filter_kwargs(func):
     return wrapper
 
 
-def framework():
+def framework() -> str | None:
     """Return name of Segmentation Models framework"""
     return _KERAS_FRAMEWORK
 
 
-def set_framework(name):
+def set_framework(name: str) -> None:
     """Set framework for Segmentation Models
 
     Args:
@@ -108,13 +110,14 @@ from . import losses, metrics, utils
 from .backbones.backbones_factory import Backbones
 from .models.fpn import FPN
 from .models.linknet import Linknet
+from .models.model_factory import get_model
 from .models.pspnet import PSPNet
 from .models.unet import Unet
 
 get_available_backbone_names = Backbones.models_names
 
 
-def get_preprocessing(name):
+def get_preprocessing(name: str) -> Callable[[Any], Any]:
     return Backbones.get_preprocessing(name)
 
 
@@ -126,6 +129,7 @@ __all__ = [
     "__version__",
     "framework",
     "get_available_backbone_names",
+    "get_model",
     "get_preprocessing",
     "losses",
     "metrics",

segmodels_keras-0.1.0.dev10/segmodels_keras/_compat.py

@@ -0,0 +1,6 @@
+"""Compatibility utilities for Keras 3 and legacy Keras 2."""
+
+import keras
+from packaging.version import parse as parse_version
+
+KERAS_GTE_3 = parse_version(keras.__version__) >= parse_version("3.0.0")

segmodels_keras-0.1.0.dev10/segmodels_keras/_version.py

@@ -0,0 +1,2 @@
+__versioninfo__: tuple[int, int, int, str] = (0, 1, 0, "dev10")
+__version__: str = ".".join(map(str, __versioninfo__))

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/backbones/_weights.py

@@ -3,9 +3,10 @@
 Source: https://github.com/qubvel/classification_models
 """
 
-from segmodels_keras._compat import load_weights
 from keras.utils import get_file
 
+from segmodels_keras.utils import load_weights
+
 __all__ = ["load_model_weights"]
 
 

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/backbones/backbones_factory.py

@@ -24,14 +24,14 @@ class BackbonesFactory:
             resnet_18_34.ResNet18,
             resnet_18_34.preprocess_input,
             # resnet18: layer1=2, layer2=2, layer3=2, layer4=2 blocks
-            # backbone output = conv5_block2_out (512ch); skips are the 4 stages before it
+            # backbone output = conv5_block2_out (512ch); skips are the 4 stages before
             ("conv4_block2_out", "conv3_block2_out", "conv2_block2_out", "conv1_relu"),
         ),
         "resnet34": (
             resnet_18_34.ResNet34,
             resnet_18_34.preprocess_input,
             # resnet34: layer1=3, layer2=4, layer3=6, layer4=3 blocks
-            # backbone output = conv5_block3_out (512ch); skips are the 4 stages before it
+            # backbone output = conv5_block3_out (512ch); skips are the 4 stages before
             ("conv4_block6_out", "conv3_block4_out", "conv2_block3_out", "conv1_relu"),
         ),
         # ResNets > 50 layers are available via keras.applications, so use those.

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/backbones/inception_resnet_v2.py

@@ -38,8 +38,7 @@ from keras import backend, layers, models
 from keras.applications import imagenet_utils
 from keras.utils import get_file, get_source_inputs
 
-from segmodels_keras._compat import load_weights
-
+from ..utils import load_weights
 from .resnet_common import _obtain_input_shape
 
 BASE_WEIGHT_URL = (

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/backbones/inception_v3.py

@@ -14,7 +14,7 @@ from keras import backend, layers, models
 from keras import utils as keras_utils
 from keras.applications import imagenet_utils
 
-from segmodels_keras._compat import load_weights
+from ..utils import load_weights
 
 WEIGHTS_PATH = (
     "https://github.com/fchollet/deep-learning-models/"

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/backbones/resnet_18_34.py

@@ -1,4 +1,4 @@
-"""ResNet18 and ResNet34 Keras models.
+"""ResNet18 and ResNet34 Keras models.
 
 Complements keras.applications (which provides ResNet50+) with BasicBlock-based
 ResNet18 and ResNet34. The implementation follows the keras.applications structure
@@ -38,8 +38,7 @@ from keras import backend, layers, models
 from keras.applications import imagenet_utils
 from keras.utils import get_source_inputs
 
-from segmodels_keras._compat import load_weights
-
+from ..utils import load_weights
 from .resnet_common import _obtain_input_shape
 
 momentum = 0.99

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/base/functional.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 import keras
 
 from segmodels_keras._compat import KERAS_GTE_3
@@ -7,7 +9,7 @@ if KERAS_GTE_3:
 else:
     from keras import backend as ops
 
-SMOOTH = 1e-5
+SMOOTH: float = 1e-5
 
 
 # ----------------------------------------------------------------
@@ -15,7 +17,7 @@ SMOOTH = 1e-5
 # ----------------------------------------------------------------
 
 
-def _gather_channels(x, indexes, **kwargs):
+def _gather_channels(x: Any, indexes: Any, **kwargs: Any) -> Any:
     backend = kwargs["backend"]
 
     """Slice tensor along channels axis by given indexes"""
@@ -30,7 +32,7 @@ def _gather_channels(x, indexes, **kwargs):
     return x
 
 
-def get_reduce_axes(per_image, **kwargs):
+def get_reduce_axes(per_image: bool, **kwargs: Any) -> list[int]:
     backend = kwargs["backend"]
 
     axes = [1, 2] if backend.image_data_format() == "channels_last" else [2, 3]
@@ -39,13 +41,15 @@ def get_reduce_axes(per_image, **kwargs):
     return axes
 
 
-def gather_channels(*xs, indexes=None, **kwargs):
+def gather_channels(
+    *xs: Any, indexes: int | list[int] | None = None, **kwargs: Any
+) -> tuple[Any, ...] | tuple[Any]:
     """Slice tensors along channels axis by given indexes"""
     if indexes is None:
         return xs
     elif isinstance(indexes, (int)):
         indexes = [indexes]
-    xs = [_gather_channels(x, indexes=indexes, **kwargs) for x in xs]
+    xs = tuple(_gather_channels(x, indexes=indexes, **kwargs) for x in xs)
     return xs
 
 

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/base/objects.py

@@ -1,10 +1,13 @@
+from typing import Any
+
+
 class KerasObject:
-    _backend = None
-    _models = None
-    _layers = None
-    _utils = None
+    _backend: Any = None
+    _models: Any = None
+    _layers: Any = None
+    _utils: Any = None
 
-    def __init__(self, name=None):
+    def __init__(self, name: str | None = None) -> None:
         if (
             self.backend is None
             or self.utils is None
@@ -16,28 +19,28 @@ class KerasObject:
         self._name = name
 
     @property
-    def __name__(self):
+    def __name__(self) -> str:
         if self._name is None:
-            return self.__class__.__name__
+            return self.__class__.__name__  # type: ignore[return-value]
         return self._name
 
     @property
-    def name(self):
+    def name(self) -> str:
         return self.__name__
 
     @name.setter
-    def name(self, name):
+    def name(self, name: str) -> None:
         self._name = name
 
     @classmethod
-    def set_submodules(cls, backend, layers, models, utils):
+    def set_submodules(cls, backend: Any, layers: Any, models: Any, utils: Any) -> None:
         cls._backend = backend
         cls._layers = layers
         cls._models = models
         cls._utils = utils
 
     @property
-    def submodules(self):
+    def submodules(self) -> dict[str, Any]:
         return {
             "backend": self.backend,
             "layers": self.layers,
@@ -46,19 +49,19 @@ class KerasObject:
         }
 
     @property
-    def backend(self):
+    def backend(self) -> Any:
         return self._backend
 
     @property
-    def layers(self):
+    def layers(self) -> Any:
         return self._layers
 
     @property
-    def models(self):
+    def models(self) -> Any:
         return self._models
 
     @property
-    def utils(self):
+    def utils(self) -> Any:
         return self._utils
 
 
@@ -67,27 +70,27 @@ class Metric(KerasObject):
 
 
 class Loss(KerasObject):
-    def __add__(self, other):
+    def __add__(self, other: Any) -> Any:
         if isinstance(other, Loss):
             return SumOfLosses(self, other)
         else:
             raise ValueError("Loss should be inherited from `Loss` class")
 
-    def __radd__(self, other):
+    def __radd__(self, other: Any) -> Any:
         return self.__add__(other)
 
-    def __mul__(self, value):
+    def __mul__(self, value: int | float) -> Any:
         if isinstance(value, (int, float)):
             return MultipliedLoss(self, value)
         else:
             raise ValueError("Loss should be inherited from `BaseLoss` class")
 
-    def __rmul__(self, other):
+    def __rmul__(self, other: Any) -> Any:
         return self.__mul__(other)
 
 
 class MultipliedLoss(Loss):
-    def __init__(self, loss, multiplier):
+    def __init__(self, loss: Any, multiplier: int | float) -> None:
 
         # resolve name
         if len(loss.__name__.split("+")) > 1:
@@ -98,16 +101,16 @@ class MultipliedLoss(Loss):
         self.loss = loss
         self.multiplier = multiplier
 
-    def __call__(self, gt, pr):
+    def __call__(self, gt: Any, pr: Any) -> Any:
         return self.multiplier * self.loss(gt, pr)
 
 
 class SumOfLosses(Loss):
-    def __init__(self, l1, l2):
+    def __init__(self, l1: Any, l2: Any) -> None:
         name = f"{l1.__name__}_plus_{l2.__name__}"
         super().__init__(name=name)
         self.l1 = l1
         self.l2 = l2
 
-    def __call__(self, gt, pr):
+    def __call__(self, gt: Any, pr: Any) -> Any:
         return self.l1(gt, pr) + self.l2(gt, pr)

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/losses.py

@@ -1,7 +1,9 @@
+from typing import Any
+
 from .base import Loss
 from .base import functional as F
 
-SMOOTH = 1e-5
+SMOOTH: float = 1e-5
 
 
 class JaccardLoss(Loss):
@@ -32,8 +34,12 @@ class JaccardLoss(Loss):
     """
 
     def __init__(
-        self, class_weights=None, class_indexes=None, per_image=False, smooth=SMOOTH
-    ):
+        self,
+        class_weights: Any = None,
+        class_indexes: Any = None,
+        per_image: bool = False,
+        smooth: float = SMOOTH,
+    ) -> None:
         super().__init__(name="jaccard_loss")
         self.class_weights = class_weights if class_weights is not None else 1
         self.class_indexes = class_indexes
@@ -92,12 +98,12 @@ class DiceLoss(Loss):
 
     def __init__(
         self,
-        beta=1,
-        class_weights=None,
-        class_indexes=None,
-        per_image=False,
-        smooth=SMOOTH,
-    ):
+        beta: int | float = 1,
+        class_weights: Any = None,
+        class_indexes: Any = None,
+        per_image: bool = False,
+        smooth: float = SMOOTH,
+    ) -> None:
         super().__init__(name="dice_loss")
         self.beta = beta
         self.class_weights = class_weights if class_weights is not None else 1
@@ -137,7 +143,7 @@ class BinaryCELoss(Loss):
         model.compile('SGD', loss=loss)
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(name="binary_crossentropy")
 
     def __call__(self, gt, pr):
@@ -168,7 +174,7 @@ class CategoricalCELoss(Loss):
         model.compile('SGD', loss=loss)
     """
 
-    def __init__(self, class_weights=None, class_indexes=None):
+    def __init__(self, class_weights: Any = None, class_indexes: Any = None) -> None:
         super().__init__(name="categorical_crossentropy")
         self.class_weights = class_weights if class_weights is not None else 1
         self.class_indexes = class_indexes
@@ -209,7 +215,9 @@ class CategoricalFocalLoss(Loss):
             model.compile('SGD', loss=loss)
     """
 
-    def __init__(self, alpha=0.25, gamma=2.0, class_indexes=None):
+    def __init__(
+        self, alpha: float = 0.25, gamma: float = 2.0, class_indexes: Any = None
+    ) -> None:
         super().__init__(name="focal_loss")
         self.alpha = alpha
         self.gamma = gamma
@@ -250,7 +258,7 @@ class BinaryFocalLoss(Loss):
         model.compile('SGD', loss=loss)
     """  # noqa: E501
 
-    def __init__(self, alpha=0.25, gamma=2.0):
+    def __init__(self, alpha: float = 0.25, gamma: float = 2.0) -> None:
         super().__init__(name="binary_focal_loss")
         self.alpha = alpha
         self.gamma = gamma
@@ -262,14 +270,14 @@ class BinaryFocalLoss(Loss):
 
 
 # aliases
-jaccard_loss = JaccardLoss()
-dice_loss = DiceLoss()
+jaccard_loss: JaccardLoss = JaccardLoss()
+dice_loss: DiceLoss = DiceLoss()
 
-binary_focal_loss = BinaryFocalLoss()
-categorical_focal_loss = CategoricalFocalLoss()
+binary_focal_loss: BinaryFocalLoss = BinaryFocalLoss()
+categorical_focal_loss: CategoricalFocalLoss = CategoricalFocalLoss()
 
-binary_crossentropy = BinaryCELoss()
-categorical_crossentropy = CategoricalCELoss()
+binary_crossentropy: BinaryCELoss = BinaryCELoss()
+categorical_crossentropy: CategoricalCELoss = CategoricalCELoss()
 
 # loss combinations
 bce_dice_loss = binary_crossentropy + dice_loss

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev10}/segmodels_keras/metrics.py

@@ -1,7 +1,9 @@
+from typing import Any
+
 from .base import Metric
 from .base import functional as F
 
-SMOOTH = 1e-5
+SMOOTH: float = 1e-5
 
 
 class IOUScore(Metric):
@@ -41,13 +43,13 @@ class IOUScore(Metric):
 
     def __init__(
         self,
-        class_weights=None,
-        class_indexes=None,
-        threshold=None,
-        per_image=False,
-        smooth=SMOOTH,
-        name=None,
-    ):
+        class_weights: Any = None,
+        class_indexes: Any = None,
+        threshold: int | float | None = None,
+        per_image: bool = False,
+        smooth: float = SMOOTH,
+        name: str | None = None,
+    ) -> None:
         name = name or "iou_score"
         super().__init__(name=name)
         self.class_weights = class_weights if class_weights is not None else 1
@@ -115,14 +117,14 @@ class FScore(Metric):
 
     def __init__(
         self,
-        beta=1,
-        class_weights=None,
-        class_indexes=None,
-        threshold=None,
-        per_image=False,
-        smooth=SMOOTH,
-        name=None,
-    ):
+        beta: int | float = 1,
+        class_weights: Any = None,
+        class_indexes: Any = None,
+        threshold: int | float | None = None,
+        per_image: bool = False,
+        smooth: float = SMOOTH,
+        name: str | None = None,
+    ) -> None:
         name = name or f"f{beta}-score"
         super().__init__(name=name)
         self.beta = beta
@@ -182,13 +184,13 @@ class Precision(Metric):
 
     def __init__(
         self,
-        class_weights=None,
-        class_indexes=None,
-        threshold=None,
-        per_image=False,
-        smooth=SMOOTH,
-        name=None,
-    ):
+        class_weights: Any = None,
+        class_indexes: Any = None,
+        threshold: int | float | None = None,
+        per_image: bool = False,
+        smooth: float = SMOOTH,
+        name: str | None = None,
+    ) -> None:
         name = name or "precision"
         super().__init__(name=name)
         self.class_weights = class_weights if class_weights is not None else 1
@@ -245,13 +247,13 @@ class Recall(Metric):
 
     def __init__(
         self,
-        class_weights=None,
-        class_indexes=None,
-        threshold=None,
-        per_image=False,
-        smooth=SMOOTH,
-        name=None,
-    ):
+        class_weights: Any = None,
+        class_indexes: Any = None,
+        threshold: int | float | None = None,
+        per_image: bool = False,
+        smooth: float = SMOOTH,
+        name: str | None = None,
+    ) -> None:
         name = name or "recall"
         super().__init__(name=name)
         self.class_weights = class_weights if class_weights is not None else 1
@@ -274,8 +276,8 @@ class Recall(Metric):
 
 
 # aliases
-iou_score = IOUScore()
-f1_score = FScore(beta=1)
-f2_score = FScore(beta=2)
-precision = Precision()
-recall = Recall()
+iou_score: IOUScore = IOUScore()
+f1_score: FScore = FScore(beta=1)
+f2_score: FScore = FScore(beta=2)
+precision: Precision = Precision()
+recall: Recall = Recall()

segmodels_keras-0.1.0.dev10/segmodels_keras/models/__init__.py

@@ -0,0 +1,5 @@
+"""Segmentation models."""
+
+from .model_factory import get_model
+
+__all__ = ["get_model"]