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

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

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

@@ -37,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.dev10 → segmodels_keras-0.1.0.dev11}/segmodels_keras/__init__.py

@@ -1,3 +1,5 @@
+"""Segmentation Models for Keras."""
+
 import functools  # noqa: I001
 import os
 from typing import Any
@@ -43,12 +45,12 @@ def filter_kwargs(func: Callable[..., Any]) -> Callable[..., Any]:
 
 
 def framework() -> str | None:
-    """Return name of Segmentation Models framework"""
+    """Return name of Segmentation Models framework."""
     return _KERAS_FRAMEWORK
 
 
 def set_framework(name: str) -> None:
-    """Set framework for Segmentation Models
+    """Set framework for Segmentation Models.
 
     Args:
         name (str): one of ``keras``, ``tf.keras``, case insensitive.
@@ -118,6 +120,7 @@ get_available_backbone_names = Backbones.models_names
 
 
 def get_preprocessing(name: str) -> Callable[[Any], Any]:
+    """Get the preprocessing function for a backbone by name."""
     return Backbones.get_preprocessing(name)
 
 

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

@@ -314,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
 
 
@@ -416,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.
@@ -443,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.dev10 → 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
@@ -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.dev10 → segmodels_keras-0.1.0.dev11}/segmodels_keras/backbones/resnet_18_34.py

@@ -109,7 +109,6 @@ def ResNet(
     Returns:
         A ``keras.Model`` instance.
     """
-
     # Determine proper input shape
     input_shape = _obtain_input_shape(
         input_shape,
@@ -358,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.dev10 → 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.dev10 → segmodels_keras-0.1.0.dev11}/segmodels_keras/base/functional.py

@@ -1,3 +1,5 @@
+"""Functional utilities for segmentation models."""
+
 from typing import Any
 
 import keras
@@ -33,6 +35,7 @@ def _gather_channels(x: Any, indexes: Any, **kwargs: Any) -> Any:
 
 
 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]
@@ -44,7 +47,7 @@ def get_reduce_axes(per_image: bool, **kwargs: Any) -> list[int]:
 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"""
+    """Slice tensors along channels axis by given indexes."""
     if indexes is None:
         return xs
     elif isinstance(indexes, (int)):
@@ -54,6 +57,7 @@ def gather_channels(
 
 
 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:
@@ -65,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:
@@ -87,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}
 
@@ -107,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]
@@ -139,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:
@@ -171,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]
@@ -224,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
@@ -273,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
@@ -296,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)
@@ -313,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)
@@ -329,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)
@@ -343,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) \
@@ -354,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

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

@@ -1,13 +1,17 @@
+"""Base objects for segmodels_keras."""
+
 from typing import Any
 
 
 class KerasObject:
+    """Base class for all objects in segmodels_keras."""
+
     _backend: Any = None
     _models: Any = None
     _layers: Any = None
     _utils: Any = None
 
-    def __init__(self, name: str | None = None) -> None:
+    def __init__(self, name: str | None = None) -> None:  # noqa: D107
         if (
             self.backend is None
             or self.utils is None
@@ -19,13 +23,13 @@ class KerasObject:
         self._name = name
 
     @property
-    def __name__(self) -> str:
+    def __name__(self) -> str:  # noqa: D105
         if self._name is None:
             return self.__class__.__name__  # type: ignore[return-value]
         return self._name
 
     @property
-    def name(self) -> str:
+    def name(self) -> str:  # noqa: D102
         return self.__name__
 
     @name.setter
@@ -33,14 +37,14 @@ class KerasObject:
         self._name = name
 
     @classmethod
-    def set_submodules(cls, backend: Any, layers: Any, models: Any, utils: Any) -> None:
+    def set_submodules(cls, backend: Any, layers: Any, models: Any, utils: Any) -> None:  # noqa: D102
         cls._backend = backend
         cls._layers = layers
         cls._models = models
         cls._utils = utils
 
     @property
-    def submodules(self) -> dict[str, Any]:
+    def submodules(self) -> dict[str, Any]:  # noqa: D102
         return {
             "backend": self.backend,
             "layers": self.layers,
@@ -49,48 +53,52 @@ class KerasObject:
         }
 
     @property
-    def backend(self) -> Any:
+    def backend(self) -> Any:  # noqa: D102
         return self._backend
 
     @property
-    def layers(self) -> Any:
+    def layers(self) -> Any:  # noqa: D102
         return self._layers
 
     @property
-    def models(self) -> Any:
+    def models(self) -> Any:  # noqa: D102
         return self._models
 
     @property
-    def utils(self) -> Any:
+    def utils(self) -> Any:  # noqa: D102
         return self._utils
 
 
 class Metric(KerasObject):
-    pass
+    """Base class for all metrics."""
 
 
 class Loss(KerasObject):
-    def __add__(self, other: Any) -> Any:
+    """Base class for all loss functions."""
+
+    def __add__(self, other: Any) -> Any:  # noqa: D105
         if isinstance(other, Loss):
             return SumOfLosses(self, other)
         else:
             raise ValueError("Loss should be inherited from `Loss` class")
 
-    def __radd__(self, other: Any) -> Any:
+    def __radd__(self, other: Any) -> Any:  # noqa: D105
         return self.__add__(other)
 
-    def __mul__(self, value: int | float) -> Any:
+    def __mul__(self, value: int | float) -> Any:  # noqa: D105
         if isinstance(value, (int, float)):
             return MultipliedLoss(self, value)
         else:
             raise ValueError("Loss should be inherited from `BaseLoss` class")
 
-    def __rmul__(self, other: Any) -> Any:
+    def __rmul__(self, other: Any) -> Any:  # noqa: D105
         return self.__mul__(other)
 
 
 class MultipliedLoss(Loss):
-    def __init__(self, loss: Any, multiplier: int | float) -> None:
+    """Class for multiplying loss by a constant value."""
+
+    def __init__(self, loss: Any, multiplier: int | float) -> None:  # noqa: D107
 
         # resolve name
         if len(loss.__name__.split("+")) > 1:
@@ -101,16 +109,21 @@ class MultipliedLoss(Loss):
         self.loss = loss
         self.multiplier = multiplier
 
-    def __call__(self, gt: Any, pr: Any) -> Any:
+    def __call__(self, gt: Any, pr: Any) -> Any:  # noqa: D102
         return self.multiplier * self.loss(gt, pr)
 
 
 class SumOfLosses(Loss):
-    def __init__(self, l1: Any, l2: Any) -> None:
+    """Class for summing two losses.
+
+    For example, you can sum DiceLoss and BinaryCELoss.
+    """
+
+    def __init__(self, l1: Any, l2: Any) -> None:  # noqa: D107
         name = f"{l1.__name__}_plus_{l2.__name__}"
         super().__init__(name=name)
         self.l1 = l1
         self.l2 = l2
 
-    def __call__(self, gt: Any, pr: Any) -> Any:
+    def __call__(self, gt: Any, pr: Any) -> Any:  # noqa: D102
         return self.l1(gt, pr) + self.l2(gt, pr)