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

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

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

@@ -0,0 +1,123 @@
+from collections import defaultdict
+from pathlib import Path
+
+import keras
+from packaging.version import parse as parse_version
+
+KERAS_GTE_3 = parse_version(keras.__version__) >= parse_version("3.0.0")
+
+
+def _is_keras_v3_weights_hdf5(filepath):
+    try:
+        import h5py  # noqa: PLC0415
+    except ImportError:
+        return False
+
+    try:
+        with h5py.File(filepath, "r") as handle:
+            return "layers" in handle and "vars" in handle
+    except OSError:
+        return False
+
+
+def _get_sorted_hdf5_var_keys(vars_group):
+    return sorted(vars_group.keys(), key=int)
+
+
+def _get_keras_v3_weighted_layers(handle):
+    import h5py  # noqa: PLC0415
+
+    weighted_layers = []
+    for layer_name in handle["layers"].keys():
+        layer_group = handle["layers"][layer_name]
+        vars_group = layer_group.get("vars")
+        if vars_group is None or not vars_group.keys():
+            continue
+
+        signature = tuple(
+            tuple(vars_group[key].shape)
+            for key in _get_sorted_hdf5_var_keys(vars_group)
+        )
+        weighted_layers.append(
+            {
+                "name": layer_name,
+                "addr": h5py.h5o.get_info(layer_group.id).addr,
+                "signature": signature,
+                "vars_group": vars_group,
+            }
+        )
+
+    weighted_layers.sort(key=lambda layer: layer["addr"])
+    return weighted_layers
+
+
+def _load_keras_v3_weights_hdf5(model, filepath):
+    import h5py  # noqa: PLC0415
+
+    with h5py.File(filepath, "r") as handle:
+        saved_layers = _get_keras_v3_weighted_layers(handle)
+        saved_layers_by_signature = defaultdict(list)
+        for saved_layer in saved_layers:
+            saved_layers_by_signature[saved_layer["signature"]].append(saved_layer)
+
+        loaded_layers = 0
+
+        for layer in model.layers:
+            if not layer.weights:
+                continue
+
+            signature = tuple(tuple(variable.shape) for variable in layer.weights)
+            if not saved_layers_by_signature[signature]:
+                raise ValueError(
+                    "Unable to locate matching Keras v3 HDF5 weights for layer "
+                    f"'{layer.name}' with shapes {list(signature)}."
+                )
+
+            vars_group = saved_layers_by_signature[signature].pop(0)["vars_group"]
+            weight_values = [
+                vars_group[key][()] for key in _get_sorted_hdf5_var_keys(vars_group)
+            ]
+            layer.set_weights(weight_values)
+            loaded_layers += 1
+
+    if loaded_layers == 0:
+        raise ValueError(
+            "No matching weighted layers found in Keras v3 HDF5 weights file: "
+            f"{filepath}"
+        )
+
+
+def load_weights(model, filepath):
+    """Load weights from an HDF5 file into a Keras model.
+
+    TensorFlow/Keras 2.10 and 2.11 can only read the legacy HDF5 format
+    (``layer_names`` attribute at the root).  Keras 3 switched to a newer
+    layout where weights are stored under ``layers/<name>/vars/<index>``.
+    When a file saved with Keras 3 is opened by the TF 2.10/2.11 loader the
+    error "found 0 saved layers" is raised because the legacy reader finds no
+    ``layer_names`` attribute.
+
+    This wrapper calls ``model.load_weights`` first.  If that raises the
+    "found 0 saved layers" ValueError *and* the file is detected as a Keras 3
+    weights HDF5 file, it falls back to a manual reader that matches each
+    model layer to its saved counterpart by weight-shape signature and file
+    creation order.
+
+    Args:
+        model: Keras model whose weights should be restored.
+        filepath (str | Path): Path to a ``.h5`` or ``.hdf5`` weights file.
+    """
+    try:
+        model.load_weights(filepath)
+    except ValueError as ex:
+        filepath = str(filepath)
+        message = str(ex)
+        is_hdf5 = Path(filepath).suffix in {".h5", ".hdf5"}
+        if (
+            not is_hdf5
+            or "found 0 saved layers" not in message
+            or not _is_keras_v3_weights_hdf5(filepath)
+        ):
+            raise
+
+        _load_keras_v3_weights_hdf5(model, filepath)

{segmodels_keras-0.1.0.dev8 → segmodels_keras-0.1.0.dev9}/segmodels_keras/_version.py

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

{segmodels_keras-0.1.0.dev8 → segmodels_keras-0.1.0.dev9}/segmodels_keras/backbones/_weights.py

@@ -3,6 +3,7 @@
 Source: https://github.com/qubvel/classification_models
 """
 
+from segmodels_keras._compat import load_weights
 from keras.utils import get_file
 
 __all__ = ["load_model_weights"]
@@ -35,7 +36,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.dev9}/segmodels_keras/backbones/inception_resnet_v2.py

@@ -38,6 +38,8 @@ 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 .resnet_common import _obtain_input_shape
 
 BASE_WEIGHT_URL = (
@@ -261,9 +263,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.dev9}/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 segmodels_keras._compat 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.dev9}/segmodels_keras/backbones/resnet_18_34.py

@@ -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,13 @@ 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 .resnet_common import _obtain_input_shape
 
+momentum = 0.99
+epsilon = 1.001e-5
+
 
 def ResNet(
     stack_fn,
@@ -141,7 +141,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 +154,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 +184,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 +226,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 +236,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 +354,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.dev9}/segmodels_keras/models/fpn.py

@@ -1,6 +1,7 @@
 from keras import backend, layers, models
 from keras import utils as keras_utils
 
+from .._compat import load_weights
 from ..backbones.backbones_factory import Backbones
 from ._common_blocks import Conv2dBn
 from ._utils import freeze_model
@@ -177,7 +178,7 @@ def build_fpn(
     # 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)
+        load_weights(model_notop, weights_notop)
         if freeze_notop:
             freeze_model(model_notop)
         x = model_notop.output
@@ -291,6 +292,6 @@ def FPN(
 
     # loading model weights
     if 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.dev9}/segmodels_keras/models/linknet.py

@@ -1,6 +1,7 @@
 from keras import backend, layers, models
 from keras import utils as keras_utils
 
+from .._compat import load_weights
 from ..backbones.backbones_factory import Backbones
 from ._common_blocks import Conv2dBn
 from ._utils import freeze_model
@@ -174,7 +175,7 @@ def build_linknet(
     # 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)
+        load_weights(model_notop, weights_notop)
         if freeze_notop:
             freeze_model(model_notop)
         x = model_notop.output
@@ -300,6 +301,6 @@ def Linknet(
 
     # loading model weights
     if 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.dev9}/segmodels_keras/models/pspnet.py

@@ -1,6 +1,7 @@
 from keras import backend, layers, models
 from keras import utils as keras_utils
 
+from .._compat import load_weights
 from ..backbones.backbones_factory import Backbones
 from ._common_blocks import Conv2dBn
 from ._utils import freeze_model
@@ -152,7 +153,7 @@ def build_psp(
     # 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)
+        load_weights(model_notop, weights_notop)
         if freeze_notop:
             freeze_model(model_notop)
         x = model_notop.output
@@ -276,6 +277,6 @@ def PSPNet(
 
     # loading model weights
     if 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.dev9}/segmodels_keras/models/unet.py

@@ -1,6 +1,7 @@
 from keras import backend, layers, models
 from keras import utils as keras_utils
 
+from .._compat import load_weights
 from ..backbones.backbones_factory import Backbones
 from ._common_blocks import Conv2dBn
 from ._utils import freeze_model
@@ -146,7 +147,8 @@ def build_unet(
     # 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)
+        load_weights(model_notop, weights_notop)
+
         if freeze_notop:
             freeze_model(model_notop)
         x = model_notop.output
@@ -271,6 +273,6 @@ def Unet(
 
     # loading model weights
     if 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.dev9}/segmodels_keras.egg-info/PKG-INFO

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

@@ -1,8 +1,10 @@
+import h5py
 import numpy as np
 import pytest
 
 import segmodels_keras as sm
 from segmodels_keras import Unet
+from segmodels_keras._compat import _load_keras_v3_weights_hdf5
 from segmodels_keras.utils import set_regularization
 
 if sm.framework() == sm._TF_KERAS_FRAMEWORK_NAME:
@@ -146,5 +148,87 @@ def test_save_model_weights_notop_invalid_decoder():
         )
 
 
+def test_load_keras_v3_style_weights_hdf5(tmp_path):
+    """Normal case: distinct weight-shape signatures per layer."""
+    inputs = keras.layers.Input(shape=(4,), name="input")
+    x = keras.layers.Dense(3, use_bias=True, name="dense")(inputs)
+    x = keras.layers.BatchNormalization(scale=False, name="batch_norm")(x)
+    outputs = keras.layers.Dense(2, use_bias=False, name="head")(x)
+    model = keras.models.Model(inputs, outputs, name="functional")
+
+    expected_weights = [weight.copy() for weight in model.get_weights()]
+    path = tmp_path / "keras_v3_style.weights.h5"
+
+    with h5py.File(path, "w") as handle:
+        layers_group = handle.create_group("layers")
+        handle.create_group("vars").attrs["name"] = model.name
+
+        for layer in model.layers:
+            layer_group = layers_group.create_group(layer.name)
+            vars_group = layer_group.create_group("vars")
+            for index, value in enumerate(layer.get_weights()):
+                vars_group.create_dataset(str(index), data=value)
+
+    zero_weights = [np.zeros_like(weight) for weight in expected_weights]
+    model.set_weights(zero_weights)
+
+    _load_keras_v3_weights_hdf5(model, path)
+
+    for actual, expected in zip(model.get_weights(), expected_weights, strict=True):
+        np.testing.assert_allclose(actual, expected)
+
+
+def test_load_keras_v3_style_weights_hdf5_duplicate_signatures(tmp_path):
+    """Layers with identical weight-shape signatures are matched in save order.
+
+    This gave an error for Keras v3 HDF5 weight files of an inceptionresnetv2 backbone.
+    """
+    # All three Dense layers share the same shape signature: [(4, 3)].
+    # The fallback must pop each candidate in file-write order so that
+    # branch_a, branch_b, and branch_c each receive their own distinct values.
+    inputs = keras.layers.Input(shape=(4,), name="input")
+    branch_a = keras.layers.Dense(3, use_bias=False, name="branch_a")(inputs)
+    branch_b = keras.layers.Dense(3, use_bias=False, name="branch_b")(inputs)
+    branch_c = keras.layers.Dense(3, use_bias=False, name="branch_c")(inputs)
+    concat_axis = 1
+    outputs = keras.layers.Concatenate(axis=concat_axis, name="concat")(
+        [branch_a, branch_b, branch_c]
+    )
+    model = keras.models.Model(inputs, outputs, name="functional")
+
+    # Assign distinct sentinel values to each dense layer so we can verify
+    # that the right values end up in the right layer after loading.
+    dense_layers = [model.get_layer(n) for n in ("branch_a", "branch_b", "branch_c")]
+    original_values = []
+    for i, layer in enumerate(dense_layers):
+        sentinel = np.full((4, 3), fill_value=float(i + 1), dtype=np.float32)
+        layer.set_weights([sentinel])
+        original_values.append(sentinel.copy())
+
+    path = tmp_path / "dup_signatures.weights.h5"
+    with h5py.File(path, "w") as handle:
+        layers_group = handle.create_group("layers")
+        handle.create_group("vars").attrs["name"] = model.name
+        for layer in model.layers:
+            layer_group = layers_group.create_group(layer.name)
+            vars_group = layer_group.create_group("vars")
+            for index, value in enumerate(layer.get_weights()):
+                vars_group.create_dataset(str(index), data=value)
+
+    # Zero out all weights before loading.
+    for layer in dense_layers:
+        layer.set_weights([np.zeros((4, 3), dtype=np.float32)])
+
+    _load_keras_v3_weights_hdf5(model, path)
+
+    for layer, expected in zip(dense_layers, original_values):
+        actual = layer.get_weights()[0]
+        np.testing.assert_allclose(
+            actual,
+            expected,
+            err_msg=f"Layer '{layer.name}' got wrong weights after loading.",
+        )
+
+
 if __name__ == "__main__":
     pytest.main([__file__])

segmodels_keras-0.1.0.dev8/segmodels_keras/_compat.py

@@ -1,4 +0,0 @@
-import keras
-from packaging.version import parse as parse_version
-
-KERAS_GTE_3 = parse_version(keras.__version__) >= parse_version("3.0.0")