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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev9
+Version: 0.1.0.dev11
 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.dev11}/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 = ["*"]
@@ -33,7 +37,7 @@ select = [
     "NPY",  # NumPy-specific rules
     "E",  # pycodestyle errors
     "W",  # pycodestyle warnings
-    # "D",  # pydocstyle
+    "D",  # pydocstyle
     "F",  # pyflakes
     "PLC",  # pylint convention
     "PLE",  # pylint error

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

@@ -1,35 +1,39 @@
+"""Segmentation Models for Keras."""
+
 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,13 +44,13 @@ def filter_kwargs(func):
     return wrapper
 
 
-def framework():
-    """Return name of Segmentation Models framework"""
+def framework() -> str | None:
+    """Return name of Segmentation Models framework."""
     return _KERAS_FRAMEWORK
 
 
-def set_framework(name):
-    """Set framework for Segmentation Models
+def set_framework(name: str) -> None:
+    """Set framework for Segmentation Models.
 
     Args:
         name (str): one of ``keras``, ``tf.keras``, case insensitive.
@@ -108,13 +112,15 @@ 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]:
+    """Get the preprocessing function for a backbone by name."""
     return Backbones.get_preprocessing(name)
 
 
@@ -126,6 +132,7 @@ __all__ = [
     "__version__",
     "framework",
     "get_available_backbone_names",
+    "get_model",
     "get_preprocessing",
     "losses",
     "metrics",

segmodels_keras-0.1.0.dev11/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.dev11/segmodels_keras/_version.py

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

segmodels_keras-0.1.0.dev11/segmodels_keras/backbones/__init__.py

@@ -0,0 +1 @@
+"""Backbones package."""

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev11}/segmodels_keras/backbones/_common_blocks.py

@@ -44,6 +44,7 @@ def GroupConv2D(
             If you don't specify anything, no activation is applied
             (ie. "linear" activation: a(x) = x).
         padding: one of "valid" or "same" (case-insensitive).
+        kwargs: additional keyword arguments (unused).
 
     Input shape:
         4D tensor with shape: (batch, rows, cols, channels) if data_format is
@@ -97,12 +98,14 @@ def expand_dims(x, channels_axis):
 
 
 def ChannelSE(reduction=16, **kwargs):  # noqa: ARG001
-    """
-    Squeeze and Excitation block, reimplementation inspired by
-        https://github.com/Cadene/pretrained-models.pytorch/blob/master/pretrainedmodels/models/senet.py
+    """Squeeze and Excitation block.
+
+    Reimplementation inspired by
+    https://github.com/Cadene/pretrained-models.pytorch/blob/master/pretrainedmodels/models/senet.py.
 
     Args:
         reduction: channels squeeze factor
+        kwargs: additional keyword arguments (unused).
 
     """
     channels_axis = 3 if backend.image_data_format() == "channels_last" else 1

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev11}/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.dev11}/segmodels_keras/backbones/backbones_factory.py

@@ -1,3 +1,6 @@
+"""Backbones factory module."""
+
+import keras
 import keras.applications as ka
 
 from . import inception_resnet_v2 as irv2
@@ -24,14 +27,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.
@@ -249,27 +252,54 @@ class BackbonesFactory:
             ),
         ],
         # EfficientNetV2
-        # Skip layers from https://github.com/chinefed/segmentation_models_fork
+        # Stage layout differs from EfficientNet-Bx.
+        # Skip layers selected to match decoder resolutions:
+        # x16 -> x8 -> x4 -> x2
+        "efficientnetv2s": (
+            ka.EfficientNetV2S,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block6a_expand_conv",  # 14x14
+                "block4a_expand_conv",  # 28x28
+                "block2a_expand_activation",  # 56x56
+                "stem_activation",  # 112x112
+            ),
+        ),
         "efficientnetv2m": (
             ka.EfficientNetV2M,
             ka.efficientnet_v2.preprocess_input,
             (
                 "block6a_expand_conv",
                 "block4a_expand_conv",
-                "block2e_add",
-                "block1c_add",
+                "block2a_expand_activation",
+                "stem_activation",
+            ),
+        ),
+        "efficientnetv2l": (
+            ka.EfficientNetV2L,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block6a_expand_conv",
+                "block4a_expand_conv",
+                "block2a_expand_activation",
+                "stem_activation",
             ),
         ),
     }
 
     @property
     def models(self):
+        """Get the dictionary of available backbones."""
         return self._models
 
     def models_names(self):
+        """Get the list of available backbone names."""
         return list(self.models.keys())
 
-    def get_backbone(self, name, *args, **kwargs):
+        """Get a backbone model by name."""
+
+    def get_backbone(self, name, *args, **kwargs) -> keras.Model:
+        """Get a backbone model by name."""
         backbone = self._models.get(name)
         if backbone is None:
             raise ValueError(f"Backbone with name '{name}' is not supported.")
@@ -279,12 +309,15 @@ class BackbonesFactory:
         return model
 
     def get_feature_layers(self, name, n=5):
+        """Get the list of skip layers for a backbone by name."""
         return self._models.get(name)[2][:n]
 
     def get_preprocessing(self, name):
+        """Get the preprocessing function for a backbone by name."""
         return self._models.get(name)[1]
 
     def get_custom_objects(self, name):
+        """Get the custom objects for a backbone by name."""
         if name == "inceptionresnetv2":
             return irv2.get_custom_objects()
         return {}

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev11}/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 = (
@@ -315,16 +314,18 @@ def conv2d_bn(
 
 
 class CustomScaleLayer(layers.Layer):
-    def __init__(self, scale, **kwargs):
+    """Custom layer to scale the residuals before adding them to the shortcut branch."""
+
+    def __init__(self, scale, **kwargs):  # noqa: D107
         super().__init__(**kwargs)
         self.scale = scale
 
-    def get_config(self):
+    def get_config(self):  # noqa: D102
         config = super().get_config()
         config.update({"scale": self.scale})
         return config
 
-    def call(self, inputs):
+    def call(self, inputs):  # noqa: D102
         return inputs[0] + inputs[1] * self.scale
 
 
@@ -417,6 +418,9 @@ def preprocess_input(x, data_format=None):
 
     Args:
         x: a 4D numpy array consists of RGB values within [0, 255].
+        data_format: image data format, either "channels_first" or
+            "channels_last". Defaults to the value found in
+            `keras.backend.image_data_format()`.
 
     Returns:
         Preprocessed array.
@@ -444,4 +448,5 @@ def decode_predictions(preds, top=5):
 
 
 def get_custom_objects():
+    """Returns a dictionary containing the custom objects used by the model."""
     return {"CustomScaleLayer": CustomScaleLayer}

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

@@ -1,10 +1,13 @@
 """Inception V3 model for Keras.
+
 Note that the input image format for this model is different than for
 the VGG16 and ResNet models (299x299 instead of 224x224),
 and that the input preprocessing function is also different (same as Xception).
-# Reference
+
+References:
+----------
 - [Rethinking the Inception Architecture for Computer Vision](
-    http://arxiv.org/abs/1512.00567) (CVPR 2016)
+    http://arxiv.org/abs/1512.00567) (CVPR 2016).
 """
 
 import os
@@ -14,7 +17,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/"
@@ -30,6 +33,7 @@ WEIGHTS_PATH_NO_TOP = (
 
 def conv2d_bn(x, filters, num_row, num_col, padding="same", strides=(1, 1), name=None):
     """Utility function to apply conv + BN.
+
     # Arguments
         x: input tensor.
         filters: filters in `Conv2D`.
@@ -76,9 +80,11 @@ def InceptionV3(
     **kwargs,  # noqa: ARG001
 ):
     """Instantiates the Inception v3 architecture.
+
     Optionally loads weights pre-trained on ImageNet.
     Note that the data format convention used by the model is
     the one specified in your Keras config at `~/.keras/keras.json`.
+
     # Arguments
         include_top: whether to include the fully-connected
             layer at the top of the network.
@@ -372,6 +378,7 @@ def InceptionV3(
 
 def preprocess_input(x, **kwargs):
     """Preprocesses a numpy array encoding a batch of images.
+
     # Arguments
         x: a 4D numpy array consists of RGB values within [0, 255].
     # Returns

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev11}/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
@@ -110,7 +109,6 @@ def ResNet(
     Returns:
         A ``keras.Model`` instance.
     """
-
     # Determine proper input shape
     input_shape = _obtain_input_shape(
         input_shape,
@@ -359,6 +357,9 @@ def preprocess_input(x, data_format=None):
 
     Args:
         x: a 4D numpy array consists of RGB values within [0, 255].
+        data_format: image data format, either "channels_first" or
+            "channels_last". Defaults to the value found in
+            `keras.backend.image_data_format()`.
 
     Returns:
         Preprocessed array.

{segmodels_keras-0.1.0.dev9 → segmodels_keras-0.1.0.dev11}/segmodels_keras/base/__init__.py

@@ -1,3 +1,5 @@
+"""Base module for segmentation models in Keras."""
+
 from . import functional as functional
 from .objects import KerasObject as KerasObject
 from .objects import Loss as Loss

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

@@ -1,3 +1,7 @@
+"""Functional utilities for segmentation models."""
+
+from typing import Any
+
 import keras
 
 from segmodels_keras._compat import KERAS_GTE_3
@@ -7,7 +11,7 @@ if KERAS_GTE_3:
 else:
     from keras import backend as ops
 
-SMOOTH = 1e-5
+SMOOTH: float = 1e-5
 
 
 # ----------------------------------------------------------------
@@ -15,7 +19,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 +34,8 @@ 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]:
+    """Get axes for reduction operations."""
     backend = kwargs["backend"]
 
     axes = [1, 2] if backend.image_data_format() == "channels_last" else [2, 3]
@@ -39,17 +44,20 @@ def get_reduce_axes(per_image, **kwargs):
     return axes
 
 
-def gather_channels(*xs, indexes=None, **kwargs):
-    """Slice tensors along channels axis by given indexes"""
+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
 
 
 def round_if_needed(x, threshold, **kwargs):
+    """Round predictions if threshold is not None."""
     if threshold is not None:
         x = ops.greater(x, threshold)
         if not KERAS_GTE_3:
@@ -61,6 +69,10 @@ def round_if_needed(x, threshold, **kwargs):
 
 
 def average(x, per_image=False, class_weights=None, **kwargs):  # noqa: ARG001
+    """Calculate the average of a tensor.
+
+    Optionally per image and with class weights.
+    """
     if per_image:
         x = ops.mean(x, axis=0)
     if class_weights is not None:
@@ -83,12 +95,14 @@ def iou_score(
     threshold=None,
     **kwargs,
 ):
-    r"""The `Jaccard index`_, also known as Intersection over Union and the Jaccard
-    similarity coefficient (originally coined coefficient de communauté by Paul
-    Jaccard), is a statistic used for comparing the similarity and diversity of sample
+    r"""The `Jaccard index`_.
+
+    Also known as Intersection over Union and the Jaccard similarity coefficient
+    (originally coined coefficient de communauté by Paul Jaccard),
+    is a statistic used for comparing the similarity and diversity of sample
     sets. The Jaccard coefficient measures similarity between finite sample sets,
     and is defined as the size of the intersection divided by the size of the union of
-    the sample sets:
+    the sample sets.
 
     .. math:: J(A, B) = \frac{A \cap B}{A \cup B}
 
@@ -103,6 +117,8 @@ def iou_score(
             else over whole batch
         threshold: value to round predictions (use ``>`` comparison), if ``None``
             prediction will not be round
+        kwargs: additional arguments, for example, ``backend`` is required for some
+            operations
 
     Returns:
         IoU/Jaccard score in range [0, 1]
@@ -135,9 +151,10 @@ def f_score(
     threshold=None,
     **kwargs,
 ):
-    r"""The F-score (Dice coefficient) can be interpreted as a weighted average of the
-    precision and recall, where an F-score reaches its best value at 1 and worst score
-    at 0.
+    r"""The F-score (Dice coefficient).
+
+    Can be interpreted as a weighted average of the precision and recall, where an
+    F-score reaches its best value at 1 and worst score at 0.
     The relative contribution of ``precision`` and ``recall`` to the F1-score are equal.
 
     The formula for the F score is:
@@ -167,6 +184,8 @@ def f_score(
             else over whole batch
         threshold: value to round predictions (use ``>`` comparison), if ``None``
             prediction will not be round
+        kwargs: additional arguments, for example, ``backend`` is required for some
+            operations
 
     Returns:
         F-score in range [0, 1]
@@ -220,6 +239,8 @@ def precision(
         threshold: Float value to round predictions (use ``>`` comparison), if ``None``
             prediction will not be round.
         name: Optional string, if ``None`` default ``precision`` name is used.
+        kwargs: additional arguments, for example, ``backend`` is required for some
+            operations
 
     Returns:
         float: precision score
@@ -269,6 +290,8 @@ def recall(
         threshold: Float value to round predictions (use ``>`` comparison), if ``None``
             prediction will not be round.
         name: Optional string, if ``None`` default ``precision`` name is used.
+        kwargs: additional arguments, for example, ``backend`` is required for some
+            operations
 
     Returns:
         float: recall score
@@ -292,6 +315,7 @@ def recall(
 
 
 def categorical_crossentropy(gt, pr, class_weights=1.0, class_indexes=None, **kwargs):
+    """Calculate categorical crossentropy loss between gt and pr tensors."""
     backend = kwargs["backend"]
 
     gt, pr = gather_channels(gt, pr, indexes=class_indexes, **kwargs)
@@ -309,11 +333,12 @@ def categorical_crossentropy(gt, pr, class_weights=1.0, class_indexes=None, **kw
 
 
 def binary_crossentropy(gt, pr, **kwargs):  # noqa: ARG001
+    """Calculate binary crossentropy loss between gt and pr tensors."""
     return ops.mean(ops.binary_crossentropy(gt, pr))
 
 
 def categorical_focal_loss(gt, pr, gamma=2.0, alpha=0.25, class_indexes=None, **kwargs):
-    r"""Implementation of Focal Loss from the paper in multiclass classification
+    r"""Implementation of Focal Loss from the paper in multiclass classification.
 
     Formula:
         loss = - gt * alpha * ((1 - pr)^gamma) * log(pr)
@@ -325,6 +350,8 @@ def categorical_focal_loss(gt, pr, gamma=2.0, alpha=0.25, class_indexes=None, **
         gamma: focusing parameter for modulating factor (1-p), default 2.0
         class_indexes: Optional integer or list of integers, classes to consider, if
             ``None`` all classes are used.
+        kwargs: additional arguments, for example, ``backend`` is required for some
+            operations
 
     """
     gt, pr = gather_channels(gt, pr, indexes=class_indexes, **kwargs)
@@ -339,7 +366,7 @@ def categorical_focal_loss(gt, pr, gamma=2.0, alpha=0.25, class_indexes=None, **
 
 
 def binary_focal_loss(gt, pr, gamma=2.0, alpha=0.25, **kwargs):  # noqa: ARG001
-    r"""Implementation of Focal Loss from the paper in binary classification
+    r"""Implementation of Focal Loss from the paper in binary classification.
 
     Formula:
         loss = - gt * alpha * ((1 - pr)^gamma) * log(pr) \
@@ -350,6 +377,8 @@ def binary_focal_loss(gt, pr, gamma=2.0, alpha=0.25, **kwargs):  # noqa: ARG001
         pr: prediction 4D keras tensor (B, H, W, C) or (B, C, H, W)
         alpha: the same as weighting factor in balanced cross entropy, default 0.25
         gamma: focusing parameter for modulating factor (1-p), default 2.0
+        kwargs: additional arguments, for example, ``backend`` is required for some
+            operations
 
     """
     # clip to prevent NaN's and Inf's