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

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

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

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

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

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

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

@@ -0,0 +1,408 @@
+"""Backbones factory module."""
+
+import keras
+import keras.applications as ka
+
+from . import inception_resnet_v2 as irv2
+from . import inception_v3 as iv3
+from . import resnet_18_34
+
+
+class BackbonesFactory:
+    """Dict with all supported backbones.
+
+    Each backbone is represented as a tuple of 3 elements:
+    1. Backbone class
+    2. Preprocessing function
+    3. List of layers to take features from backbone in the following order:
+       (x16, x8, x4, x2, x1) - `x4` mean that features has 4 times less spatial
+       resolution (Height x Width) than input image.
+    """
+
+    _models = {  # noqa: RUF012
+        # Feature sizes in comments are HxWxC for a 512x512 input.
+        # ResNets < 50 layers are NOT available via keras.applications, so use a
+        # torchvision-compatible post-activation BasicBlock implementation.
+        # Layer names follow the keras.applications ResNet50+ naming convention.
+        "resnet18": (
+            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
+            (
+                "conv4_block2_out",  # 32x32x256
+                "conv3_block2_out",  # 64x64x128
+                "conv2_block2_out",  # 128x128x64
+                "conv1_relu",  # 256x256x64
+            ),
+        ),
+        "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
+            (
+                "conv4_block6_out",  # 32x32x256
+                "conv3_block4_out",  # 64x64x128
+                "conv2_block3_out",  # 128x128x64
+                "conv1_relu",  # 256x256x64
+            ),
+        ),
+        # ResNets > 50 layers are available via keras.applications, so use those.
+        # Skip layers (inverted) from https://github.com/yingkaisha/keras-unet-collection
+        "resnet50": (
+            ka.ResNet50,
+            ka.resnet.preprocess_input,
+            (
+                "conv4_block6_out",  # 32x32x1024
+                "conv3_block4_out",  # 64x64x512
+                "conv2_block3_out",  # 128x128x256
+                "conv1_relu",  # 256x256x64
+            ),
+        ),
+        "resnet101": (
+            ka.ResNet101,
+            ka.resnet.preprocess_input,
+            (
+                "conv4_block23_out",  # 32x32x1024
+                "conv3_block4_out",  # 64x64x512
+                "conv2_block3_out",  # 128x128x256
+                "conv1_relu",  # 256x256x64
+            ),
+        ),
+        "resnet152": (
+            ka.ResNet152,
+            ka.resnet.preprocess_input,
+            (
+                "conv4_block36_out",  # 32x32x1024
+                "conv3_block8_out",  # 64x64x512
+                "conv2_block3_out",  # 128x128x256
+                "conv1_relu",  # 256x256x64
+            ),
+        ),
+        # ResNetV2
+        # Skip layers (inverted) from https://github.com/yingkaisha/keras-unet-collection
+        "resnet50v2": (
+            ka.ResNet50V2,
+            ka.resnet_v2.preprocess_input,
+            (
+                "conv4_block6_1_relu",  # 32x32x256
+                "conv3_block4_1_relu",  # 64x64x128
+                "conv2_block3_1_relu",  # 128x128x64
+                "conv1_conv",  # 256x256x64
+            ),
+        ),
+        "resnet101v2": (
+            ka.ResNet101V2,
+            ka.resnet_v2.preprocess_input,
+            (
+                "conv4_block23_1_relu",  # 32x32x256
+                "conv3_block4_1_relu",  # 64x64x128
+                "conv2_block3_1_relu",  # 128x128x64
+                "conv1_conv",  # 256x256x64
+            ),
+        ),
+        "resnet152v2": (
+            ka.ResNet152V2,
+            ka.resnet_v2.preprocess_input,
+            (
+                "conv4_block36_1_relu",  # 32x32x256
+                "conv3_block8_1_relu",  # 64x64x128
+                "conv2_block3_1_relu",  # 128x128x64
+                "conv1_conv",  # 256x256x64
+            ),
+        ),
+        # VGG
+        # Skip layers from segmentation_models
+        "vgg16": (
+            ka.vgg16.VGG16,
+            ka.vgg16.preprocess_input,
+            (
+                "block5_conv3",  # 32x32x512
+                "block4_conv3",  # 64x64x512
+                "block3_conv3",  # 128x128x256
+                "block2_conv2",  # 256x256x128
+                "block1_conv2",  # 512x512x64
+            ),
+        ),
+        "vgg19": (
+            ka.vgg19.VGG19,
+            ka.vgg19.preprocess_input,
+            (
+                "block5_conv4",  # 32x32x512
+                "block4_conv4",  # 64x64x512
+                "block3_conv4",  # 128x128x256
+                "block2_conv2",  # 256x256x128
+                "block1_conv2",  # 512x512x64
+            ),
+        ),
+        # DenseNet
+        # Skip layers (inverted) from https://github.com/yingkaisha/keras-unet-collection
+        "densenet121": (
+            ka.densenet.DenseNet121,
+            ka.densenet.preprocess_input,
+            (
+                "pool4_conv",  # 32x32x512
+                "pool3_conv",  # 64x64x256
+                "pool2_conv",  # 128x128x128
+                "conv1/relu",  # 256x256x64
+            ),
+        ),
+        "densenet169": (
+            ka.densenet.DenseNet169,
+            ka.densenet.preprocess_input,
+            (
+                "pool4_conv",  # 32x32x640
+                "pool3_conv",  # 64x64x256
+                "pool2_conv",  # 128x128x128
+                "conv1/relu",  # 256x256x64
+            ),
+        ),
+        "densenet201": (
+            ka.densenet.DenseNet201,
+            ka.densenet.preprocess_input,
+            (
+                "pool4_conv",  # 32x32x896
+                "pool3_conv",  # 64x64x256
+                "pool2_conv",  # 128x128x128
+                "conv1/relu",  # 256x256x64
+            ),
+        ),
+        # Inception
+        # Skip layers from segmentation_models
+        "inceptionresnetv2": (
+            irv2.InceptionResNetV2,
+            irv2.preprocess_input,
+            # Use the layer indexes instead of names because otherwise loading weights
+            # saved with keras 2 cannot be loaded with keras 3.
+            # (
+            #     "activation_161",
+            #     "activation_74",
+            #     "activation_3",
+            #     "activation",
+            #     # "input_1",
+            # ),
+            (
+                594,  # 32x32x1088
+                260,  # 64x64x320
+                16,  # 128x128x192
+                9,  # 256x256x64
+            ),
+        ),
+        "inceptionv3": (
+            iv3.InceptionV3,
+            iv3.preprocess_input,
+            (
+                228,  # 32x32x768
+                86,  # 64x64x288
+                16,  # 128x128x192
+                9,  # 256x256x64
+            ),
+        ),
+        # MobileNet
+        # Skip layers from segmentation_models
+        "mobilenet": (
+            ka.mobilenet.MobileNet,
+            ka.mobilenet.preprocess_input,
+            (
+                "conv_pw_11_relu",  # 32x32x512
+                "conv_pw_5_relu",  # 64x64x256
+                "conv_pw_3_relu",  # 128x128x128
+                "conv_pw_1_relu",  # 256x256x64
+            ),
+        ),
+        "mobilenetv2": (
+            ka.mobilenet_v2.MobileNetV2,
+            ka.mobilenet_v2.preprocess_input,
+            (
+                "block_13_expand_relu",  # 32x32x576
+                "block_6_expand_relu",  # 64x64x192
+                "block_3_expand_relu",  # 128x128x144
+                "block_1_expand_relu",  # 256x256x96
+            ),
+        ),
+        # EfficientNet
+        # Skip layers from segmentation_models
+        "efficientnetb0": [
+            ka.EfficientNetB0,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x672
+                "block4a_expand_activation",  # 64x64x240
+                "block3a_expand_activation",  # 128x128x144
+                "block2a_expand_activation",  # 256x256x96
+            ),
+        ],
+        "efficientnetb1": [
+            ka.EfficientNetB1,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x672
+                "block4a_expand_activation",  # 64x64x240
+                "block3a_expand_activation",  # 128x128x144
+                "block2a_expand_activation",  # 256x256x96
+            ),
+        ],
+        "efficientnetb2": [
+            ka.EfficientNetB2,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x720
+                "block4a_expand_activation",  # 64x64x288
+                "block3a_expand_activation",  # 128x128x144
+                "block2a_expand_activation",  # 256x256x96
+            ),
+        ],
+        "efficientnetb3": [
+            ka.EfficientNetB3,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x816
+                "block4a_expand_activation",  # 64x64x288
+                "block3a_expand_activation",  # 128x128x192
+                "block2a_expand_activation",  # 256x256x144
+            ),
+        ],
+        "efficientnetb4": [
+            ka.EfficientNetB4,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x960
+                "block4a_expand_activation",  # 64x64x336
+                "block3a_expand_activation",  # 128x128x192
+                "block2a_expand_activation",  # 256x256x144
+            ),
+        ],
+        "efficientnetb5": [
+            ka.EfficientNetB5,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x1056
+                "block4a_expand_activation",  # 64x64x384
+                "block3a_expand_activation",  # 128x128x240
+                "block2a_expand_activation",  # 256x256x144
+            ),
+        ],
+        "efficientnetb6": [
+            ka.EfficientNetB6,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x1200
+                "block4a_expand_activation",  # 64x64x432
+                "block3a_expand_activation",  # 128x128x240
+                "block2a_expand_activation",  # 256x256x192
+            ),
+        ],
+        "efficientnetb7": [
+            ka.EfficientNetB7,
+            ka.efficientnet.preprocess_input,
+            (
+                "block6a_expand_activation",  # 32x32x1344
+                "block4a_expand_activation",  # 64x64x480
+                "block3a_expand_activation",  # 128x128x288
+                "block2a_expand_activation",  # 256x256x192
+            ),
+        ],
+        # EfficientNetV2
+        # 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",  # 32x32x960
+                "block4a_expand_conv",  # 64x64x256
+                "block2a_expand_activation",  # 128x128x96
+                "stem_activation",  # 256x256x24
+            ),
+        ),
+        "efficientnetv2s-ss": (
+            ka.EfficientNetV2S,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block5i_add",  # 32x32x160
+                "block3d_add",  # 64x64x64
+                "block2d_add",  # 128x128x48
+                "stem_activation",  # 256x256x24
+            ),
+        ),
+        "efficientnetv2m": (
+            ka.EfficientNetV2M,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block6a_expand_conv",  # 32x32x1056
+                "block4a_expand_conv",  # 64x64x320
+                "block2a_expand_activation",  # 128x128x96
+                "stem_activation",  # 256x256x24
+            ),
+        ),
+        "efficientnetv2m-ss": (
+            ka.EfficientNetV2M,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block5n_add",  # 32x32x176
+                "block3e_add",  # 64x64x80
+                "block2e_add",  # 128x128x48
+                "stem_activation",  # 256x256x24
+            ),
+        ),
+        "efficientnetv2l": (
+            ka.EfficientNetV2L,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block6a_expand_conv",  # 32x32x1344
+                "block4a_expand_conv",  # 64x64x384
+                "block2a_expand_activation",  # 128x128x128
+                "stem_activation",  # 256x256x32
+            ),
+        ),
+        "efficientnetv2l-ss": (
+            ka.EfficientNetV2L,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block5s_add",  # 32x32x224
+                "block3g_add",  # 64x64x96
+                "block2g_add",  # 128x128x64
+                "stem_activation",  # 256x256x32
+            ),
+        ),
+    }
+
+    @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())
+
+        """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.")
+
+        model_fn, _, _ = backbone
+        model = model_fn(*args, **kwargs)
+        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 {}
+
+
+Backbones = BackbonesFactory()

{segmodels_keras-0.1.0.dev10 → segmodels_keras-0.1.0.dev12}/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.dev12}/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.dev12}/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.dev12}/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