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

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

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

@@ -51,6 +51,7 @@ ignore = [
     ### Intentionally disabled
     "E402",     # Module level import not at top of file
     "PLR0913",  # Too many arguments to function call
+    "PLR0917",  # Too many positional arguments
     "PLR0911",  # Too many returns
     "PLR0912",  # Too many branches
     "PLR0915",  # Too many statements

segmodels_keras-0.1.0.dev13/segmodels_keras/_version.py

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

{segmodels_keras-0.1.0.dev12 → segmodels_keras-0.1.0.dev13}/segmodels_keras/backbones/backbones_factory.py

@@ -307,43 +307,68 @@ class BackbonesFactory:
         # Stage layout differs from EfficientNet-Bx.
         # Skip layers selected to match decoder resolutions:
         # x16 -> x8 -> x4 -> x2
-        "efficientnetv2s": (
-            ka.EfficientNetV2S,
+        #
+        # Tests with more compact skip connection layers ("block5i_add" (32x32x160),
+        # "block3d_add" (64x64x64), "block2d_add" (128x128x48), "stem_activation"
+        # (256x256x24)) showed that the decrease in model size was small (30 MB) but
+        # the accuracy performance impact was significant (-1.5%).
+        "efficientnetv2b0": (
+            ka.EfficientNetV2B0,
             ka.efficientnet_v2.preprocess_input,
             (
-                "block6a_expand_conv",  # 32x32x960
-                "block4a_expand_conv",  # 64x64x256
-                "block2a_expand_activation",  # 128x128x96
-                "stem_activation",  # 256x256x24
+                "block4b_expand_conv",  # 32x32x384
+                "block3a_expand_conv",  # 64x64x128
+                "block2a_expand_activation",  # 128x128x64
+                "stem_activation",  # 256x256x32
             ),
         ),
-        "efficientnetv2s-ss": (
-            ka.EfficientNetV2S,
+        "efficientnetv2b1": (
+            ka.EfficientNetV2B1,
             ka.efficientnet_v2.preprocess_input,
             (
-                "block5i_add",  # 32x32x160
-                "block3d_add",  # 64x64x64
-                "block2d_add",  # 128x128x48
-                "stem_activation",  # 256x256x24
+                "block4b_expand_conv",  # 32x32x384
+                "block3a_expand_conv",  # 64x64x128
+                "block2a_expand_activation",  # 128x128x64
+                "stem_activation",  # 256x256x32
             ),
         ),
-        "efficientnetv2m": (
-            ka.EfficientNetV2M,
+        "efficientnetv2b2": (
+            ka.EfficientNetV2B2,
             ka.efficientnet_v2.preprocess_input,
             (
-                "block6a_expand_conv",  # 32x32x1056
-                "block4a_expand_conv",  # 64x64x320
+                "block4b_expand_conv",  # 32x32x416
+                "block3a_expand_conv",  # 64x64x128
+                "block2a_expand_activation",  # 128x128x64
+                "stem_activation",  # 256x256x32
+            ),
+        ),
+        "efficientnetv2b3": (
+            ka.EfficientNetV2B3,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block4b_expand_conv",  # 32x32x448
+                "block3a_expand_conv",  # 64x64x160
+                "block2a_expand_activation",  # 128x128x64
+                "stem_activation",  # 256x256x40
+            ),
+        ),
+        "efficientnetv2s": (
+            ka.EfficientNetV2S,
+            ka.efficientnet_v2.preprocess_input,
+            (
+                "block6a_expand_conv",  # 32x32x960
+                "block4a_expand_conv",  # 64x64x256
                 "block2a_expand_activation",  # 128x128x96
                 "stem_activation",  # 256x256x24
             ),
         ),
-        "efficientnetv2m-ss": (
+        "efficientnetv2m": (
             ka.EfficientNetV2M,
             ka.efficientnet_v2.preprocess_input,
             (
-                "block5n_add",  # 32x32x176
-                "block3e_add",  # 64x64x80
-                "block2e_add",  # 128x128x48
+                "block6a_expand_conv",  # 32x32x1056
+                "block4a_expand_conv",  # 64x64x320
+                "block2a_expand_activation",  # 128x128x96
                 "stem_activation",  # 256x256x24
             ),
         ),
@@ -357,16 +382,6 @@ class BackbonesFactory:
                 "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

{segmodels_keras-0.1.0.dev12 → segmodels_keras-0.1.0.dev13}/segmodels_keras.egg-info/PKG-INFO

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

@@ -0,0 +1,23 @@
+"""Tests on the backbone factory and backbone retrieval."""
+
+import pytest
+
+from segmodels_keras.backbones.backbones_factory import BackbonesFactory
+
+
+def test_backbones_factory():
+    factory = BackbonesFactory()
+    assert len(factory.models) > 0
+
+    for name in factory.models.keys():
+        model_fn, preprocess_fn, layers = factory.models[name]
+        assert callable(model_fn)
+        assert callable(preprocess_fn)
+        assert isinstance(layers, tuple)
+
+
+def test_get_backbone_unknown():
+    factory = BackbonesFactory()
+
+    with pytest.raises(ValueError):
+        factory.get_backbone("unknown")

{segmodels_keras-0.1.0.dev12 → segmodels_keras-0.1.0.dev13}/tests/test_models.py

@@ -22,28 +22,25 @@ def str2bool(v):
     return v.lower() in ("yes", "true", "t", "1")
 
 
-def get_test_backbones():
-    is_full = str2bool(os.environ.get("FULL_TEST", "False"))
+def get_test_backbones(with_weights: bool):
+    if with_weights:
+        is_full = str2bool(os.environ.get("FULL_TEST", "False"))
+    else:
+        is_full = str2bool(os.environ.get("FULL_TEST_WEIGHTS", "False"))
+
     if not is_full:
-        return [
-            "resnet34",
-            "resnet50",
-            "inceptionresnetv2",
-            "efficientnetb0",
-            "efficientnetv2s",
-            "efficientnetv2s-ss",
-            "efficientnetv2m-ss",
-            "efficientnetv2l-ss",
-        ]
+        return ["resnet34", "resnet50", "inceptionresnetv2", "efficientnetb0"]
     else:
         return get_available_backbone_names()
 
 
 def keras_test(func):
     """Function wrapper to clean up after TensorFlow tests.
-    # Arguments
+
+    Args:
         func: test function to clean up after.
-    # Returns
+
+    Returns:
         A function wrapping the input function.
     """
 
@@ -56,40 +53,37 @@ def keras_test(func):
     return wrapper
 
 
-@pytest.mark.parametrize("backbone_name", get_test_backbones())
+@pytest.mark.parametrize("backbone_name", get_test_backbones(with_weights=False))
 @pytest.mark.parametrize(
-    "model_name, input_shape, encoder_weights",
+    "model_name, input_shape",
     [
-        ("unet", None, None),
-        ("unet", None, "imagenet"),
-        ("unet", (256, 256, 4), None),
-        ("linknet", None, None),
-        ("linknet", (256, 256, 4), None),
-        ("pspnet", (384, 384, 4), None),
-        ("fpn", None, None),
-        ("fpn", (256, 256, 4), None),
+        ("unet", None),
+        ("unet", (256, 256, 4)),
+        ("linknet", None),
+        ("linknet", (256, 256, 4)),
+        ("pspnet", (384, 384, 4)),
+        ("fpn", None),
+        ("fpn", (256, 256, 4)),
     ],
 )
 @keras_test
-def test_get_model(model_name, backbone_name, input_shape, encoder_weights):
-    """Test all segmentation models with different backbones.
+def test_get_model(model_name, backbone_name, input_shape):
+    """Test creation of model/backbone combinations.
 
-    input_shape=None means any shape (32x32 used in test), otherwise a fixed shape is
-    used.
+    No weights are used in this test to avoid downloading pretrained models.
     """
-    n_channels = 3 if input_shape is None else input_shape[-1]
-    test_shape = (1, 32, 32, n_channels) if input_shape is None else (1, *input_shape)
+    _assert_get_model_output_shape(model_name, backbone_name, input_shape, None)
 
-    x = np.ones(test_shape)
-    model = get_model(
-        model_name,
-        backbone_name=backbone_name,
-        input_shape=input_shape or (None, None, n_channels),
-        encoder_weights=encoder_weights,
-    )
-    y = model.predict(x)
 
-    assert x.shape[:-1] == y.shape[:-1]
+@pytest.mark.parametrize("backbone_name", get_test_backbones(with_weights=True))
+@keras_test
+def test_get_model_with_imagenet_weights(backbone_name):
+    """Test model creation with ImageNet-pretrained encoder weights.
+
+    Only tested on a limited set of backbones as this will download the pretrained
+    weights.
+    """
+    _assert_get_model_output_shape("unet", backbone_name, None, "imagenet")
 
 
 def test_get_model_invalid_name():
@@ -98,43 +92,6 @@ def test_get_model_invalid_name():
         get_model("invalid_model")
 
 
-@pytest.mark.parametrize(
-    "standard_backbone, compact_backbone, expected_parameter_reduction",
-    [
-        ("efficientnetv2s", "efficientnetv2s-ss", 2_092_032),
-        ("efficientnetv2m", "efficientnetv2m-ss", 2_331_648),
-        ("efficientnetv2l", "efficientnetv2l-ss", 2_949_120),
-    ],
-)
-@keras_test
-def test_efficientnetv2_compact_skips_reduce_unet_parameters(
-    standard_backbone, compact_backbone, expected_parameter_reduction
-):
-    input_shape = (32, 32, 3)
-    standard_model = get_model(
-        "unet",
-        backbone_name=standard_backbone,
-        input_shape=input_shape,
-        encoder_weights=None,
-    )
-    standard_params = standard_model.count_params()
-    standard_output_shape = standard_model.output_shape
-    del standard_model
-    keras.backend.clear_session()
-
-    compact_model = get_model(
-        "unet",
-        backbone_name=compact_backbone,
-        input_shape=input_shape,
-        encoder_weights=None,
-    )
-
-    assert compact_model.output_shape == standard_output_shape
-    assert (
-        standard_params - compact_model.count_params() == expected_parameter_reduction
-    )
-
-
 def test_get_model_weights_notop_keras2():
     """Test loading a Keras v2 style HDF5 weight file."""
     weights_path = data_dir / "mobilenetv2+linknet_notop_k2.weights.h5"
@@ -153,5 +110,19 @@ def test_get_model_weights_notop_keras3():
     assert len(model.layers) > 0
 
 
-if __name__ == "__main__":
-    pytest.main([__file__])
+def _assert_get_model_output_shape(
+    model_name, backbone_name, input_shape, encoder_weights
+):
+    n_channels = 3 if input_shape is None else input_shape[-1]
+    test_shape = (1, 32, 32, n_channels) if input_shape is None else (1, *input_shape)
+
+    x = np.ones(test_shape)
+    model = get_model(
+        model_name,
+        backbone_name=backbone_name,
+        input_shape=input_shape or (None, None, n_channels),
+        encoder_weights=encoder_weights,
+    )
+    y = model.predict(x)
+
+    assert x.shape[:-1] == y.shape[:-1]

segmodels_keras-0.1.0.dev12/segmodels_keras/_version.py

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

segmodels_keras-0.1.0.dev12/tests/test_backbones.py

@@ -1,57 +0,0 @@
-"""Tests on the backbone factory and backbone retrieval."""
-
-import pytest
-
-from segmodels_keras.backbones.backbones_factory import BackbonesFactory
-
-
-def test_backbones_factory():
-    factory = BackbonesFactory()
-    assert len(factory.models) > 0
-
-    for name in factory.models.keys():
-        model_fn, preprocess_fn, layers = factory.models[name]
-        assert callable(model_fn)
-        assert callable(preprocess_fn)
-        assert isinstance(layers, tuple)
-
-
-def test_get_backbone_unknown():
-    factory = BackbonesFactory()
-
-    with pytest.raises(ValueError):
-        factory.get_backbone("unknown")
-
-
-@pytest.mark.parametrize(
-    "backbone_name, expected_shapes",
-    [
-        (
-            "efficientnetv2s-ss",
-            ((4, 4, 160), (8, 8, 64), (16, 16, 48), (32, 32, 24)),
-        ),
-        (
-            "efficientnetv2m-ss",
-            ((4, 4, 176), (8, 8, 80), (16, 16, 48), (32, 32, 24)),
-        ),
-        (
-            "efficientnetv2l-ss",
-            ((4, 4, 224), (8, 8, 96), (16, 16, 64), (32, 32, 32)),
-        ),
-    ],
-)
-def test_efficientnetv2_compact_skip_shapes(backbone_name, expected_shapes):
-    factory = BackbonesFactory()
-    model = factory.get_backbone(
-        backbone_name,
-        include_top=False,
-        weights=None,
-        input_shape=(64, 64, 3),
-    )
-
-    feature_shapes = tuple(
-        tuple(int(size) for size in model.get_layer(layer_name).output.shape[1:])
-        for layer_name in factory.get_feature_layers(backbone_name, n=4)
-    )
-
-    assert feature_shapes == expected_shapes