segmodels-keras 0.1.0.dev3__tar.gz → 0.1.0.dev5__tar.gz

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev3
+Version: 0.1.0.dev5
 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.dev3 → segmodels_keras-0.1.0.dev5}/README.rst

@@ -1,8 +1,11 @@
-|Actions Status| |PyPI version|
+|Actions Status| |Code coverage| |PyPI version|
 
 .. |Actions Status| image:: https://github.com/orthoseg/segmodels_keras/actions/workflows/tests.yml/badge.svg?branch=main
    :target: https://github.com/orthoseg/segmodels_keras/actions/workflows/tests.yml?query=workflow%3ATests
 
+.. |Code coverage| image:: https://codecov.io/gh/orthoseg/segmodels_keras/graph/badge.svg?token=o01OyTMDuj 
+   :target: https://codecov.io/gh/orthoseg/segmodels_keras
+
 .. |PyPI version| image:: https://img.shields.io/pypi/v/segmodels-keras.svg
    :target: https://pypi.org/project/segmodels-keras
 

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/__init__.py

@@ -2,9 +2,9 @@ import functools  # noqa: I001
 import os
 
 # __version__ should be defined as soon as possible
-from segmodels_keras._version import __version__
+from ._version import __version__
 
-from segmodels_keras import base
+from . import base
 
 _KERAS_FRAMEWORK_NAME = "keras"
 _TF_KERAS_FRAMEWORK_NAME = "tf.keras"

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/_version.py

@@ -1,2 +1,2 @@
-__versioninfo__ = (0, 1, 0, "dev3")
+__versioninfo__ = (0, 1, 0, "dev5")
 __version__ = ".".join(map(str, __versioninfo__))

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/backbones/backbones_factory.py

@@ -274,5 +274,10 @@ class BackbonesFactory:
     def get_preprocessing(self, name):
         return self._models.get(name)[1]
 
+    def get_custom_objects(self, name):
+        if name == "inceptionresnetv2":
+            return irv2.get_custom_objects()
+        return {}
+
 
 Backbones = BackbonesFactory()

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/backbones/inception_resnet_v2.py

@@ -30,8 +30,6 @@ are the following:
   https://github.com/ayushdabra/dubai-satellite-imagery-segmentation/blob/9446e16134e752dda080ba9d65be18ea47fa26a9/get_activations.py#L40
 - The keras.applications implementation uses different imports as it is internal in
   keras, and here we need to use the public API of keras.
-- Keep using the Lambda layer instead of CustomScaleLayer to avoid having to pass it in
-  with `custom_objects` when loading the model.
 """
 
 import warnings
@@ -39,7 +37,6 @@ from pathlib import Path
 
 from keras import backend, layers, models
 from keras.applications import imagenet_utils
-from keras.layers import Layer
 from keras.utils import get_file, get_source_inputs
 
 BASE_WEIGHT_URL = (
@@ -314,6 +311,20 @@ def conv2d_bn(
     return x
 
 
+class CustomScaleLayer(layers.Layer):
+    def __init__(self, scale, **kwargs):
+        super().__init__(**kwargs)
+        self.scale = scale
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"scale": self.scale})
+        return config
+
+    def call(self, inputs):
+        return inputs[0] + inputs[1] * self.scale
+
+
 def inception_resnet_block(x, scale, block_type, block_idx, activation="relu"):
     """Adds a Inception-ResNet block.
 
@@ -390,12 +401,7 @@ def inception_resnet_block(x, scale, block_type, block_idx, activation="relu"):
         name=f"{block_name}_conv",
     )
 
-    x = layers.Lambda(
-        lambda inputs, scale: inputs[0] + inputs[1] * scale,
-        output_shape=x.shape[1:],
-        arguments={"scale": scale},
-        name=block_name,
-    )([x, up])
+    x = CustomScaleLayer(scale)([x, up])
 
     if activation is not None:
         x = layers.Activation(activation, name=f"{block_name}_ac")(x)
@@ -434,6 +440,10 @@ def decode_predictions(preds, top=5):
     return imagenet_utils.decode_predictions(preds, top=top)
 
 
+def get_custom_objects():
+    return {"CustomScaleLayer": CustomScaleLayer}
+
+
 def _obtain_input_shape(
     input_shape,
     default_size,

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/models/fpn.py

@@ -107,6 +107,7 @@ def build_fpn(
     use_batchnorm=True,
     aggregation="sum",
     dropout=None,
+    weights_notop=None,
 ):
     input_ = backbone.input
     x = backbone.output
@@ -172,6 +173,12 @@ def build_fpn(
         size=(2, 2), interpolation="bilinear", name="final_upsampling"
     )(x)
 
+    # load weights without top if path provided
+    if weights_notop is not None:
+        model_notop = models.Model(input_, x)
+        model_notop.load_weights(weights_notop)
+        x = model_notop.output
+
     # model head (define number of output classes)
     x = layers.Conv2D(
         filters=classes,
@@ -200,6 +207,7 @@ def FPN(
     classes=21,
     activation="softmax",
     weights=None,
+    weights_notop=None,
     encoder_weights="imagenet",
     encoder_freeze=False,
     encoder_features="default",
@@ -219,7 +227,9 @@ def FPN(
             your model be able to process images af any size, but ``H`` and ``W`` of
             input images should be divisible by factor ``32``.
         classes: a number of classes for output (output shape - ``(h, w, classes)``).
-        weights: optional, path to model weights.
+        weights: optional, path to model weights to be loaded.
+        weights_notop: optional, path to model weights without top (without segmentation
+            head) to be loaded.
         activation: name of one of ``keras.activations`` for last model layer
             (e.g. ``sigmoid``, ``softmax``, ``linear``).
         encoder_weights: one of ``None`` (random initialization), ``imagenet``
@@ -265,6 +275,7 @@ def FPN(
         activation=activation,
         classes=classes,
         aggregation=pyramid_aggregation,
+        weights_notop=weights_notop,
     )
 
     # lock encoder weights for fine-tuning

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/models/linknet.py

@@ -141,6 +141,7 @@ def build_linknet(
     classes=1,
     activation="sigmoid",
     use_batchnorm=True,
+    weights_notop=None,
 ):
     input_ = backbone.input
     x = backbone.output
@@ -169,6 +170,12 @@ def build_linknet(
             x, skip
         )
 
+    # load weights without top if path provided
+    if weights_notop is not None:
+        model_notop = models.Model(input_, x)
+        model_notop.load_weights(weights_notop)
+        x = model_notop.output
+
     # model head (define number of output classes)
     x = layers.Conv2D(
         filters=classes,
@@ -196,6 +203,7 @@ def Linknet(
     classes=1,
     activation="sigmoid",
     weights=None,
+    weights_notop=None,
     encoder_weights="imagenet",
     encoder_freeze=False,
     encoder_features="default",
@@ -219,7 +227,9 @@ def Linknet(
         classes: a number of classes for output (output shape - ``(h, w, classes)``).
         activation: name of one of ``keras.activations`` for last model layer
             (e.g. ``sigmoid``, ``softmax``, ``linear``).
-        weights: optional, path to model weights.
+        weights: optional, path to model weights to be loaded.
+        weights_notop: optional, path to model weights without top (without segmentation
+            head) to be loaded.
         encoder_weights: one of ``None`` (random initialization), ``imagenet``
             (pre-training on ImageNet).
         encoder_freeze: if ``True`` set all layers of encoder (backbone model) as
@@ -274,6 +284,7 @@ def Linknet(
         activation=activation,
         n_upsample_blocks=len(decoder_filters),
         use_batchnorm=decoder_use_batchnorm,
+        weights_notop=weights_notop,
     )
 
     # lock encoder weights for fine-tuning

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/models/pspnet.py

@@ -124,6 +124,7 @@ def build_psp(
     classes=21,
     activation="softmax",
     dropout=None,
+    weights_notop=None,
 ):
     input_ = backbone.input
     x = (
@@ -147,6 +148,12 @@ def build_psp(
     if dropout is not None:
         x = layers.SpatialDropout2D(dropout, name="spatial_dropout")(x)
 
+    # load weights without top if path provided
+    if weights_notop is not None:
+        model_notop = models.Model(input_, x)
+        model_notop.load_weights(weights_notop)
+        x = model_notop.output
+
     # model head
     x = layers.Conv2D(
         filters=classes,
@@ -177,6 +184,7 @@ def PSPNet(
     classes=21,
     activation="softmax",
     weights=None,
+    weights_notop=None,
     encoder_weights="imagenet",
     encoder_freeze=False,
     downsample_factor=8,
@@ -197,7 +205,9 @@ def PSPNet(
         classes: a number of classes for output (output shape - ``(h, w, classes)``).
         activation: name of one of ``keras.activations`` for last model layer
             (e.g. ``sigmoid``, ``softmax``, ``linear``).
-        weights: optional, path to model weights.
+        weights: optional, path to model weights to be loaded.
+        weights_notop: optional, path to model weights without top (without segmentation
+            head) to be loaded.
         encoder_weights: one of ``None`` (random initialization), ``imagenet``
             (pre-training on ImageNet).
         encoder_freeze: if ``True`` set all layers of encoder (backbone model) as
@@ -250,6 +260,7 @@ def PSPNet(
         classes=classes,
         activation=activation,
         dropout=psp_dropout,
+        weights_notop=weights_notop,
     )
 
     # lock encoder weights for fine-tuning

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/models/unet.py

@@ -113,6 +113,7 @@ def build_unet(
     classes=1,
     activation="sigmoid",
     use_batchnorm=True,
+    weights_notop=None,
 ):
     input_ = backbone.input
     x = backbone.output
@@ -141,6 +142,12 @@ def build_unet(
             x, skip
         )
 
+    # load weights without top if path provided
+    if weights_notop is not None:
+        model_notop = models.Model(input_, x)
+        model_notop.load_weights(weights_notop)
+        x = model_notop.output
+
     # model head (define number of output classes)
     x = layers.Conv2D(
         filters=classes,
@@ -169,6 +176,7 @@ def Unet(
     classes=1,
     activation="sigmoid",
     weights=None,
+    weights_notop=None,
     encoder_weights="imagenet",
     encoder_freeze=False,
     encoder_features="default",
@@ -190,7 +198,9 @@ def Unet(
         classes: a number of classes for output (output shape - ``(h, w, classes)``).
         activation: name of one of ``keras.activations`` for last model layer
             (e.g. ``sigmoid``, ``softmax``, ``linear``).
-        weights: optional, path to model weights.
+        weights: optional, path to model weights to be loaded.
+        weights_notop: optional, path to model weights without top (without segmentation
+            head) to be loaded.
         encoder_weights: one of ``None`` (random initialization), ``imagenet``
             (pre-training on ImageNet).
         encoder_freeze: if ``True`` set all layers of encoder (backbone model) as
@@ -245,6 +255,7 @@ def Unet(
         activation=activation,
         n_upsample_blocks=len(decoder_filters),
         use_batchnorm=decoder_use_batchnorm,
+        weights_notop=weights_notop,
     )
 
     # lock encoder weights for fine-tuning

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras/utils.py

@@ -1,8 +1,40 @@
 """Utility functions for segmentation models"""
 
+from pathlib import Path
+
 from keras import models
 
 
+def save_model_weights_notop(
+    model: models.Model, decoder: str, path: str | Path, overwrite: bool = True
+):
+    """Save model weights without top (without segmentation head).
+
+    The weights saved like this can be used to preload a segmentation model for
+    fine-tuning by passing the path to these weights to ``weights_notop`` argument of
+    the model constructor, e.g. ``Unet(weights_notop="path/to/weights.h5")``.
+
+    Args:
+        model (``keras.models.Model``): instance of keras model
+        decoder: type of the decoder part of the model. Should be one of ``fpn``,
+            ``linknet``, ``unet``, ``pspnet``.
+        path (str | Path): path to save model weights
+        overwrite (bool): whether to overwrite existing file at ``path``.
+            Defaults to ``True``.
+
+    """
+    decoder_top_layers = {"fpn": 2, "linknet": 2, "unet": 2, "pspnet": 3}
+    if decoder not in decoder_top_layers:
+        raise ValueError(
+            f"Decoder should be one of {decoder_top_layers.keys()}, got {decoder}"
+        )
+
+    # Add 1 to the slice to actually remove the number of top layers specified
+    nb_top_layers = decoder_top_layers[decoder] + 1
+    model_notop = models.Model(model.input, model.layers[-nb_top_layers].output)
+    model_notop.save_weights(str(path), overwrite=overwrite)
+
+
 def set_trainable(model, recompile=True, **kwargs):  # noqa: ARG001
     """Set all layers of model trainable and recompile it
 

{segmodels_keras-0.1.0.dev3 → segmodels_keras-0.1.0.dev5}/segmodels_keras.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev3
+Version: 0.1.0.dev5
 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.dev3 → segmodels_keras-0.1.0.dev5}/tests/test_utils.py

@@ -106,5 +106,45 @@ def test_activity_reg(case):
     _test_regularizer(model, reg_model, x, y)
 
 
+@pytest.mark.parametrize("decoder", ["fpn", "linknet", "unet", "pspnet"])
+def test_save_model_weights_notop(tmp_path, decoder):
+    backbone_name = "mobilenetv2"
+    if decoder == "pspnet":
+        model = sm.PSPNet(backbone_name, encoder_weights=None)
+    elif decoder == "fpn":
+        model = sm.FPN(backbone_name, encoder_weights=None)
+    elif decoder == "linknet":
+        model = sm.Linknet(backbone_name, encoder_weights=None)
+    elif decoder == "unet":
+        model = sm.Unet(backbone_name, encoder_weights=None)
+    else:
+        raise ValueError(f"Incorrect decoder {decoder}")
+
+    # Test saving the model weights without the top layers
+    path = tmp_path / f"{decoder}.weights.h5"
+    sm.utils.save_model_weights_notop(model, decoder=decoder, path=path)
+
+    # Test loading the model weights without the top layers again
+    assert path.exists()
+    if decoder == "pspnet":
+        model = sm.PSPNet(backbone_name, weights_notop=path)
+    elif decoder == "fpn":
+        model = sm.FPN(backbone_name, weights_notop=path)
+    elif decoder == "linknet":
+        model = sm.Linknet(backbone_name, weights_notop=path)
+    elif decoder == "unet":
+        model = sm.Unet(backbone_name, weights_notop=path)
+    else:
+        raise ValueError(f"Incorrect decoder {decoder}")
+
+
+def test_save_model_weights_notop_invalid_decoder():
+    model = keras.models.Model()
+    with pytest.raises(ValueError, match="Decoder should be one of"):
+        sm.utils.save_model_weights_notop(
+            model, decoder="invalid_decoder", path="path/to/weights.h5"
+        )
+
+
 if __name__ == "__main__":
     pytest.main([__file__])