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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev8
+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.dev8 → 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.dev8 → 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.dev8 → segmodels_keras-0.1.0.dev10}/segmodels_keras/_compat.py

@@ -1,3 +1,5 @@
+"""Compatibility utilities for Keras 3 and legacy Keras 2."""
+
 import keras
 from packaging.version import parse as parse_version
 

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.dev8 → segmodels_keras-0.1.0.dev10}/segmodels_keras/backbones/_weights.py

@@ -5,6 +5,8 @@ Source: https://github.com/qubvel/classification_models
 
 from keras.utils import get_file
 
+from segmodels_keras.utils import load_weights
+
 __all__ = ["load_model_weights"]
 
 
@@ -35,7 +37,7 @@ def load_model_weights(model, model_name, dataset, classes, include_top):
             md5_hash=weights["md5"],
         )
 
-        model.load_weights(weights_path)
+        load_weights(model, weights_path)
 
     else:
         raise ValueError(

{segmodels_keras-0.1.0.dev8 → 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.dev8 → segmodels_keras-0.1.0.dev10}/segmodels_keras/backbones/inception_resnet_v2.py

@@ -38,6 +38,7 @@ from keras import backend, layers, models
 from keras.applications import imagenet_utils
 from keras.utils import get_file, get_source_inputs
 
+from ..utils import load_weights
 from .resnet_common import _obtain_input_shape
 
 BASE_WEIGHT_URL = (
@@ -261,9 +262,9 @@ def InceptionResNetV2(
                 cache_subdir="models",
                 file_hash="d19885ff4a710c122648d3b5c3b684e4",
             )
-        model.load_weights(weights_path)
+        load_weights(model, weights_path)
     elif weights is not None:
-        model.load_weights(weights)
+        load_weights(model, weights)
 
     return model
 

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

@@ -14,6 +14,8 @@ from keras import backend, layers, models
 from keras import utils as keras_utils
 from keras.applications import imagenet_utils
 
+from ..utils import load_weights
+
 WEIGHTS_PATH = (
     "https://github.com/fchollet/deep-learning-models/"
     "releases/download/v0.5/"
@@ -361,9 +363,9 @@ def InceptionV3(
                 cache_subdir="models",
                 file_hash="bcbd6486424b2319ff4ef7d526e38f63",
             )
-        model.load_weights(weights_path)
+        load_weights(model, weights_path)
     elif weights is not None:
-        model.load_weights(weights)
+        load_weights(model, weights)
 
     return model
 

{segmodels_keras-0.1.0.dev8 → 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
@@ -14,27 +14,22 @@ closely so that the two can be maintained together:
 Layer naming follows the same ``conv{N}_block{M}_*`` convention used by
 keras.applications, so models built here share the same weight-loading patterns.
 
-Note that the resulting resnet18 and resnet34 are not exactly the same as the version
-in https://github.com/qubvel/classification_models and hence is also different than
-the segmentation models in https://github.com/qubvel/segmentation_models.
-There are some differences in the bottom and top layers of the resnet, e.g. because
-the classification_models version applies also post-activation after the last residual
-block.
-
-This implementation is designed to be compatible with torchvision ResNet18/34 pretrained
-weights. Because the resnet implementation in keras.applications.resnet.ResNet (which
-only supports ResNet50+) already uses the same bottom and top layers this implementation
-is based on it, but in addition the following tweaks have been applied:
-- BatchNormalization uses ``momentum=0.9`` and ``epsilon=1e-5`` (torchvision defaults)
-  instead of the keras.applications defaults of ``momentum=0.99`` and
-  ``epsilon=1.001e-5``.
-  Note that momentum is only used during training. In addition, the value in pytorch
-  is inverted compared to the tf.keras implementation, so the default in pytorch
-  is actually ``momentum=0.1``, but after inversion we use ``momentum=0.9`` here.
-- The single bottom convolutional layer gets ``use_bias=False`` (like all convolutional
-  layers in the model just like the version in torchvision and in segmentation_models.
-  In the keras.applications ResNet(50+) implementation ``use_bias=True`` is used for the
-  single bottom convolutional layer.
+Notes:
+  - The resulting resnet18 and resnet34 are not exactly the same as the version in
+    https://github.com/qubvel/classification_models and hence is also different than
+    the segmentation models in https://github.com/qubvel/segmentation_models.
+    There are some differences in the bottom and top layers of the resnet, e.g. because
+    the classification_models version applies also post-activation after the last
+    residual block.
+  - The implementation is also ~ compatible with torchvision ResNet18/34 pretrained
+    weights based on a (rough) test. There are some small differences, but they don't
+    seem to influance the results significantly:
+      - BatchNormalization in torchvision uses ``momentum=0.9`` and ``epsilon=1e-5``
+        instead of the keras.applications defaults of ``momentum=0.99`` and
+        ``epsilon=1.001e-5`` used here.
+        Note that momentum is only used during training. In addition, the value in
+        pytorch is inverted compared to the tf.keras implementation, so the default in
+        pytorch is actually ``momentum=0.1``, but inverted this gives ``momentum=0.9``.
 """
 
 import os
@@ -43,8 +38,12 @@ from keras import backend, layers, models
 from keras.applications import imagenet_utils
 from keras.utils import get_source_inputs
 
+from ..utils import load_weights
 from .resnet_common import _obtain_input_shape
 
+momentum = 0.99
+epsilon = 1.001e-5
+
 
 def ResNet(
     stack_fn,
@@ -141,7 +140,7 @@ def ResNet(
         # The batchnormalization parameters have been changed to be compatible with the
         # torchvision ResNet18/34 pretrained weights.
         x = layers.BatchNormalization(
-            axis=bn_axis, momentum=0.1, epsilon=1e-5, name="conv1_bn"
+            axis=bn_axis, momentum=momentum, epsilon=epsilon, name="conv1_bn"
         )(x)
         x = layers.Activation("relu", name="conv1_relu")(x)
 
@@ -154,7 +153,7 @@ def ResNet(
         # The batchnormalization parameters have been changed to be compatible with the
         # torchvision ResNet18/34 pretrained weights.
         x = layers.BatchNormalization(
-            axis=bn_axis, momentum=0.1, epsilon=1e-5, name="post_bn"
+            axis=bn_axis, momentum=momentum, epsilon=epsilon, name="post_bn"
         )(x)
         x = layers.Activation("relu", name="post_relu")(x)
 
@@ -184,7 +183,7 @@ def ResNet(
     model = models.Model(inputs, x, name=name)
 
     if weights is not None and os.path.exists(weights):
-        model.load_weights(weights)
+        load_weights(model, weights)
 
     return model
 
@@ -226,7 +225,7 @@ def residual_basicblock(
             filters, 1, strides=stride, use_bias=False, name=f"{name}_0_conv"
         )(x)
         shortcut = layers.BatchNormalization(
-            axis=bn_axis, momentum=0.1, epsilon=1e-5, name=f"{name}_0_bn"
+            axis=bn_axis, momentum=momentum, epsilon=epsilon, name=f"{name}_0_bn"
         )(shortcut)
     else:
         shortcut = x
@@ -236,14 +235,14 @@ def residual_basicblock(
         filters, kernel_size, strides=stride, use_bias=False, name=f"{name}_1_conv"
     )(x)
     x = layers.BatchNormalization(
-        axis=bn_axis, momentum=0.1, epsilon=1e-5, name=f"{name}_1_bn"
+        axis=bn_axis, momentum=momentum, epsilon=epsilon, name=f"{name}_1_bn"
     )(x)
     x = layers.Activation("relu", name=f"{name}_1_relu")(x)
 
     x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name=f"{name}_2_pad")(x)
     x = layers.Conv2D(filters, kernel_size, use_bias=False, name=f"{name}_2_conv")(x)
     x = layers.BatchNormalization(
-        axis=bn_axis, momentum=0.1, epsilon=1e-5, name=f"{name}_2_bn"
+        axis=bn_axis, momentum=momentum, epsilon=epsilon, name=f"{name}_2_bn"
     )(x)
 
     x = layers.Add(name=f"{name}_add")([shortcut, x])
@@ -354,15 +353,13 @@ def ResNet34(
     )
 
 
-def preprocess_input(x, **kwargs):
-    """Torchvision-compatible ImageNet normalization (input in [0, 1])."""
-    import numpy as np
+def preprocess_input(x, data_format=None):
+    """Preprocesses a numpy array encoding a batch of images.
 
-    # FLAIR-compatible normalization (input in [0, 255]).
-    mean = np.array([105.08, 110.87, 101.82, 106.38, 53.26], dtype="float32")
-    std = np.array([52.17, 45.38, 44, 39.69, 79.3], dtype="float32")
+    Args:
+        x: a 4D numpy array consists of RGB values within [0, 255].
 
-    # Torchvision-compatible ImageNet normalization (input in [0, 1]).
-    # mean = np.array([0.485, 0.456, 0.406], dtype="float32")
-    # std = np.array([0.229, 0.224, 0.225], dtype="float32")
-    return (x - mean) / std
+    Returns:
+        Preprocessed array.
+    """
+    return imagenet_utils.preprocess_input(x, data_format=data_format, mode="tf")

{segmodels_keras-0.1.0.dev8 → 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.dev8 → 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.dev8 → 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