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

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

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

@@ -24,7 +24,9 @@ improvements and support for some extra backbone models.
 It is not meant as a full replacement of the original library, but rather as a
 solution for a library I developed and depended on segmentation_models:
 `orthoseg <https://github.com/orthoseg/orthoseg>`__ . Hence, full backwards
-compatibility,... or support for all features is not guaranteed.
+compatibility or support for all features is not an explicit goal. For example,
+the resnet backbones got small changes compared to the original library, so existing
+weights you saved for them won't be compatible.
 
 
 **The main features** of this library are:

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

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

{segmodels_keras-0.1.0.dev7 → segmodels_keras-0.1.0.dev8}/segmodels_keras/backbones/backbones_factory.py

@@ -2,7 +2,7 @@ import keras.applications as ka
 
 from . import inception_resnet_v2 as irv2
 from . import inception_v3 as iv3
-from . import resnet
+from . import resnet_18_34
 
 
 class BackbonesFactory:
@@ -17,17 +17,22 @@ class BackbonesFactory:
     """
 
     _models = {  # noqa: RUF012
-        # ResNets < 50 layers are NOT available via keras.applications, so use
-        # implementation from classification_models.
+        # 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.ResNet18,
-            resnet.preprocess_input,
-            ("stage4_unit1_relu1", "stage3_unit1_relu1", "stage2_unit1_relu1", "relu0"),
+            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 it
+            ("conv4_block2_out", "conv3_block2_out", "conv2_block2_out", "conv1_relu"),
         ),
         "resnet34": (
-            resnet.ResNet34,
-            resnet.preprocess_input,
-            ("stage4_unit1_relu1", "stage3_unit1_relu1", "stage2_unit1_relu1", "relu0"),
+            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 it
+            ("conv4_block6_out", "conv3_block4_out", "conv2_block3_out", "conv1_relu"),
         ),
         # ResNets > 50 layers are available via keras.applications, so use those.
         # Skip layers (inverted) from https://github.com/yingkaisha/keras-unet-collection

{segmodels_keras-0.1.0.dev7 → segmodels_keras-0.1.0.dev8}/segmodels_keras/backbones/inception_resnet_v2.py

@@ -32,13 +32,14 @@ are the following:
   keras, and here we need to use the public API of keras.
 """
 
-import warnings
 from pathlib import Path
 
 from keras import backend, layers, models
 from keras.applications import imagenet_utils
 from keras.utils import get_file, get_source_inputs
 
+from .resnet_common import _obtain_input_shape
+
 BASE_WEIGHT_URL = (
     "https://storage.googleapis.com/tensorflow/keras-applications/inception_resnet_v2/"
 )
@@ -442,119 +443,3 @@ def decode_predictions(preds, top=5):
 
 def get_custom_objects():
     return {"CustomScaleLayer": CustomScaleLayer}
-
-
-def _obtain_input_shape(
-    input_shape,
-    default_size,
-    min_size,
-    data_format,
-    require_flatten,
-    weights=None,
-):
-    """Internal utility to compute/validate a model's input shape.
-
-    Args:
-      input_shape: Either None (will return the default network input shape),
-        or a user-provided shape to be validated.
-      default_size: Default input width/height for the model.
-      min_size: Minimum input width/height accepted by the model.
-      data_format: Image data format to use.
-      require_flatten: Whether the model is expected to
-        be linked to a classifier via a Flatten layer.
-      weights: One of `None` (random initialization)
-        or 'imagenet' (pre-training on ImageNet).
-        If weights='imagenet' input channels must be equal to 3.
-
-    Returns:
-      An integer shape tuple (may include None entries).
-
-    Raises:
-      ValueError: In case of invalid argument values.
-    """
-    if weights != "imagenet" and input_shape and len(input_shape) == 3:
-        if data_format == "channels_first":
-            correct_channel_axis = 1 if len(input_shape) == 4 else 0
-            if input_shape[correct_channel_axis] not in {1, 3}:
-                warnings.warn(
-                    "This model usually expects 1 or 3 input channels. "
-                    "However, it was passed an input_shape "
-                    f"with {input_shape[0]} input channels.",
-                    stacklevel=2,
-                )
-            default_shape = (input_shape[0], default_size, default_size)
-        else:
-            if input_shape[-1] not in {1, 3}:
-                warnings.warn(
-                    "This model usually expects 1 or 3 input channels. "
-                    "However, it was passed an input_shape "
-                    f"with {input_shape[-1]} input channels.",
-                    stacklevel=2,
-                )
-            default_shape = (default_size, default_size, input_shape[-1])
-    else:
-        if data_format == "channels_first":
-            default_shape = (3, default_size, default_size)
-        else:
-            default_shape = (default_size, default_size, 3)
-    if weights == "imagenet" and require_flatten:
-        if input_shape is not None:
-            if input_shape != default_shape:
-                raise ValueError(
-                    "When setting `include_top=True` "
-                    "and loading `imagenet` weights, "
-                    f"`input_shape` should be {default_shape}.  "
-                    f"Received: input_shape={input_shape}"
-                )
-        return default_shape
-    if input_shape:
-        if data_format == "channels_first":
-            if input_shape is not None:
-                if len(input_shape) != 3:
-                    raise ValueError("`input_shape` must be a tuple of three integers.")
-                if input_shape[0] != 3 and weights == "imagenet":
-                    raise ValueError(
-                        "The input must have 3 channels; Received "
-                        f"`input_shape={input_shape}`"
-                    )
-                if (input_shape[1] is not None and input_shape[1] < min_size) or (
-                    input_shape[2] is not None and input_shape[2] < min_size
-                ):
-                    raise ValueError(
-                        f"Input size must be at least {min_size}"
-                        f"x{min_size}; Received: "
-                        f"input_shape={input_shape}"
-                    )
-        else:
-            if input_shape is not None:
-                if len(input_shape) != 3:
-                    raise ValueError("`input_shape` must be a tuple of three integers.")
-                if input_shape[-1] != 3 and weights == "imagenet":
-                    raise ValueError(
-                        "The input must have 3 channels; Received "
-                        f"`input_shape={input_shape}`"
-                    )
-                if (input_shape[0] is not None and input_shape[0] < min_size) or (
-                    input_shape[1] is not None and input_shape[1] < min_size
-                ):
-                    raise ValueError(
-                        "Input size must be at least "
-                        f"{min_size}x{min_size}; Received: "
-                        f"input_shape={input_shape}"
-                    )
-    else:
-        if require_flatten:
-            input_shape = default_shape
-        else:
-            if data_format == "channels_first":
-                input_shape = (3, None, None)
-            else:
-                input_shape = (None, None, 3)
-    if require_flatten:
-        if None in input_shape:
-            raise ValueError(
-                "If `include_top` is True, "
-                "you should specify a static `input_shape`. "
-                f"Received: input_shape={input_shape}"
-            )
-    return input_shape

segmodels_keras-0.1.0.dev8/segmodels_keras/backbones/resnet_18_34.py

@@ -0,0 +1,368 @@
+"""ResNet18 and ResNet34 Keras models.
+
+Complements keras.applications (which provides ResNet50+) with BasicBlock-based
+ResNet18 and ResNet34. The implementation follows the keras.applications structure
+closely so that the two can be maintained together:
+
+  - ``ResNet(stack_fn, ...)`` is the generic builder, matching the signature of
+    ``keras.applications.resnet.ResNet``.
+  - ``residual_basicblock(x, filters, ..., name)`` is the BasicBlock equivalent of
+    ``keras.applications.resnet.residual_block_v1``.
+  - ``stack_residual_basicblocks(x, filters, blocks, ..., name)`` groups blocks into a
+    stage, equivalent to ``keras.applications.resnet.stack_residual_blocks_v1``.
+
+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.
+"""
+
+import os
+
+from keras import backend, layers, models
+from keras.applications import imagenet_utils
+from keras.utils import get_source_inputs
+
+from .resnet_common import _obtain_input_shape
+
+
+def ResNet(
+    stack_fn,
+    preact,
+    use_bias,
+    include_top=True,
+    weights=None,
+    input_tensor=None,
+    input_shape=None,
+    pooling=None,
+    classes=1000,
+    classifier_activation="softmax",
+    name="resnet",
+):
+    """Generic ResNet builder for BasicBlock variants (ResNet18/34).
+
+    Follows the same signature as ``keras.applications.resnet.ResNet`` so that
+    both can be used interchangeably.
+
+    Args:
+        stack_fn: A function that returns output tensor for the
+            stacked residual blocks.
+        preact: Whether to use pre-activation (BN before conv). `True` for ResNetV2,
+            `False` (post-activation) for ResNet (including ResNet18/34) and ResNeXt.
+        use_bias: Whether to use bias for the single bottom convolutional layer or not.
+            `True` for ResNet and ResNetV2 in the standard keras.applications
+            implementation, `False` for ResNeXt. However, for torchvision compatibility
+            we will use False here for ResNet18/34.
+        include_top: Whether to include the fully-connected layer at the top of the
+            network (=classification head). Defaults to ``True``.
+        weights: Path to a weights file to load, or ``None``. Defaults to
+            ``None``.
+        input_tensor: Optional Keras tensor to use as the model input.
+            (i.e. output of `layers.Input()`)
+        input_shape: Optional shape tuple, only to be specified
+            if `include_top` is `False` (otherwise the input shape
+            has to be `(224, 224, 3)` (with `channels_last` data format)
+            or `(3, 224, 224)` (with `"channels_first"` data format). It
+            should have exactly 3 inputs channels.
+        pooling: Optional pooling mode for feature extraction
+            when `include_top` is `False`.
+            - `None` means that the output of the model will be
+                the 4D tensor output of the
+                last convolutional layer.
+            - `avg` means that global average pooling
+                will be applied to the output of the
+                last convolutional layer, and thus
+                the output of the model will be a 2D tensor.
+            - `max` means that global max pooling will
+                be applied.
+        classes: optional number of classes to classify images
+            into, only to be specified if `include_top` is `True`,
+            and if no `weights` argument is specified.
+            Defaults to ``1000``.
+        classifier_activation: A `str` or callable. The activation
+            function to use on the "top" layer. Ignored unless
+            `include_top=True`. Set `classifier_activation=None` to
+            return the logits of the "top" layer. When loading
+            pretrained weights, `classifier_activation` can only be
+            `None` or `"softmax"`. Defaults to ``"softmax"``.
+        name: The name of the model (string). Defaults to ``"resnet"``.
+
+    Returns:
+        A ``keras.Model`` instance.
+    """
+
+    # Determine proper input shape
+    input_shape = _obtain_input_shape(
+        input_shape,
+        default_size=224,
+        min_size=32,
+        data_format=backend.image_data_format(),
+        require_flatten=include_top,
+        weights=weights,
+    )
+
+    if input_tensor is None:
+        img_input = layers.Input(shape=input_shape)
+    else:
+        if not backend.is_keras_tensor(input_tensor):
+            img_input = layers.Input(tensor=input_tensor, shape=input_shape)
+        else:
+            img_input = input_tensor
+
+    if backend.image_data_format() == "channels_last":
+        bn_axis = 3
+    else:
+        bn_axis = 1
+
+    x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name="conv1_pad")(img_input)
+    x = layers.Conv2D(64, 7, strides=2, use_bias=use_bias, name="conv1_conv")(x)
+
+    if not preact:
+        # 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"
+        )(x)
+        x = layers.Activation("relu", name="conv1_relu")(x)
+
+    x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name="pool1_pad")(x)
+    x = layers.MaxPooling2D(3, strides=2, name="pool1_pool")(x)
+
+    x = stack_fn(x)
+
+    if preact:
+        # 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"
+        )(x)
+        x = layers.Activation("relu", name="post_relu")(x)
+
+    if include_top:
+        x = layers.GlobalAveragePooling2D(name="avg_pool")(x)
+
+        # Validate activation for the classifier layer
+        imagenet_utils.validate_activation(classifier_activation, weights)
+
+        x = layers.Dense(classes, activation=classifier_activation, name="predictions")(
+            x
+        )
+    else:
+        if pooling == "avg":
+            x = layers.GlobalAveragePooling2D(name="avg_pool")(x)
+        elif pooling == "max":
+            x = layers.GlobalMaxPooling2D(name="max_pool")(x)
+
+    # Ensure that the model takes into account
+    # any potential predecessors of `input_tensor`.
+    if input_tensor is not None:
+        inputs = get_source_inputs(input_tensor)
+    else:
+        inputs = img_input
+
+    # Create model.
+    model = models.Model(inputs, x, name=name)
+
+    if weights is not None and os.path.exists(weights):
+        model.load_weights(weights)
+
+    return model
+
+
+def residual_basicblock(
+    x, filters, kernel_size=3, stride=1, conv_shortcut=True, name=None
+):
+    """A BasicBlock residual block for ResNet18/34.
+
+    Similar to ``keras.applications.resnet.residual_block_v1`` that is used for
+    ResNet50+, but with following differences for resnet 18/34:
+    - two 3x3 convolutions instead of the 1x1 / 3x3 / 1x1 bottleneck.
+    - ``use_bias=False`` instead of ``True``
+
+    Following changes have been applied to be compatible with torchvision ResNet18/34
+    pretrained weights:
+    - BN momentum is set to 0.1 instead of 0.99
+    - BN epsilon is set to 1e-5 instead of 1.001e-5
+
+    Args:
+        x: Input tensor.
+        filters: No of filters for both 3x3 convolutions.
+        kernel_size: Kernel size of the 3x3 convolutions. Defaults to ``3``.
+        stride: Stride of the first convolution. Defaults to ``1``.
+        conv_shortcut: Use a strided 1x1 conv on the shortcut path if ``True``,
+            otherwise use an identity shortcut. Defaults to ``True``.
+        name: Block name prefix, e.g. ``"conv3_block1"``.
+
+    Returns:
+        Output tensor for the block.
+    """
+    if backend.image_data_format() == "channels_last":
+        bn_axis = 3
+    else:
+        bn_axis = 1
+
+    if conv_shortcut:
+        shortcut = layers.Conv2D(
+            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"
+        )(shortcut)
+    else:
+        shortcut = x
+
+    x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name=f"{name}_1_pad")(x)
+    x = layers.Conv2D(
+        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"
+    )(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"
+    )(x)
+
+    x = layers.Add(name=f"{name}_add")([shortcut, x])
+    x = layers.Activation("relu", name=f"{name}_out")(x)
+    return x
+
+
+def stack_residual_basicblocks(x, filters, blocks, stride1=2, name=None):
+    """A set of stacked BasicBlock residual blocks forming one ResNet stage.
+
+    Similar to ``keras.applications.resnet.stack_residual_blocks_v1``.
+
+    Args:
+        x: Input tensor.
+        filters: Number of filters for all blocks in this stage.
+        blocks: Number of BasicBlocks in the stage.
+        stride1: Stride of the first block (use ``2`` to downsample spatially,
+            ``1`` for the first stage where spatial size is unchanged). Defaults
+            to ``2``.
+        name: Stage name prefix, e.g. ``"conv3"``.
+
+    Returns:
+        Output tensor for the stacked blocks.
+    """
+    x = residual_basicblock(
+        x, filters, stride=stride1, conv_shortcut=stride1 > 1, name=f"{name}_block1"
+    )
+    for i in range(2, blocks + 1):
+        x = residual_basicblock(
+            x, filters, conv_shortcut=False, name=f"{name}_block{i}"
+        )
+    return x
+
+
+def ResNet18(
+    include_top=True,
+    weights=None,
+    input_tensor=None,
+    input_shape=None,
+    pooling=None,
+    classes=1000,
+    classifier_activation="softmax",
+    name="resnet18",
+    use_bias=False,
+):
+    """Instantiates the ResNet18 architecture with torchvision-compatible tweaks.
+
+    Remark: torchvision uses bias=False, keras.applications ResNet uses bias=True, but
+    for torchvision compatibility we will use False here.
+    """
+
+    def stack_fn(x):
+        x = stack_residual_basicblocks(x, 64, 2, stride1=1, name="conv2")
+        x = stack_residual_basicblocks(x, 128, 2, stride1=2, name="conv3")
+        x = stack_residual_basicblocks(x, 256, 2, stride1=2, name="conv4")
+        return stack_residual_basicblocks(x, 512, 2, stride1=2, name="conv5")
+
+    return ResNet(
+        stack_fn,
+        preact=False,  # torchvision ResNet18/34 is post-activation (Conv -> BN -> ReLU)
+        use_bias=use_bias,
+        name=name,
+        include_top=include_top,
+        weights=weights,
+        input_tensor=input_tensor,
+        input_shape=input_shape,
+        pooling=pooling,
+        classes=classes,
+        classifier_activation=classifier_activation,
+    )
+
+
+def ResNet34(
+    include_top=True,
+    weights=None,
+    input_tensor=None,
+    input_shape=None,
+    pooling=None,
+    classes=1000,
+    classifier_activation="softmax",
+    name="resnet34",
+    use_bias=False,
+):
+    """Instantiates the ResNet34 architecture with torchvision-compatible tweaks.
+
+    Remark: torchvision uses bias=False, keras.applications ResNet uses bias=True, but
+    for torchvision compatibility we will use False here.
+    """
+
+    def stack_fn(x):
+        x = stack_residual_basicblocks(x, 64, 3, stride1=1, name="conv2")
+        x = stack_residual_basicblocks(x, 128, 4, stride1=2, name="conv3")
+        x = stack_residual_basicblocks(x, 256, 6, stride1=2, name="conv4")
+        return stack_residual_basicblocks(x, 512, 3, stride1=2, name="conv5")
+
+    return ResNet(
+        stack_fn,
+        preact=False,  # torchvision ResNet18/34 is post-activation (Conv -> BN -> ReLU)
+        use_bias=use_bias,
+        name=name,
+        include_top=include_top,
+        weights=weights,
+        input_tensor=input_tensor,
+        input_shape=input_shape,
+        pooling=pooling,
+        classes=classes,
+        classifier_activation=classifier_activation,
+    )
+
+
+def preprocess_input(x, **kwargs):
+    """Torchvision-compatible ImageNet normalization (input in [0, 1])."""
+    import numpy as np
+
+    # 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")
+
+    # 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

segmodels_keras-0.1.0.dev8/segmodels_keras/backbones/resnet_common.py

@@ -0,0 +1,122 @@
+"""Some common utilities for ResNet backbones.
+
+Source: keras.applications.
+"""
+
+import warnings
+
+
+def _obtain_input_shape(
+    input_shape,
+    default_size,
+    min_size,
+    data_format,
+    require_flatten,
+    weights=None,
+):
+    """Internal utility to compute/validate a model's input shape.
+
+    Args:
+      input_shape: Either None (will return the default network input shape),
+        or a user-provided shape to be validated.
+      default_size: Default input width/height for the model.
+      min_size: Minimum input width/height accepted by the model.
+      data_format: Image data format to use.
+      require_flatten: Whether the model is expected to
+        be linked to a classifier via a Flatten layer.
+      weights: One of `None` (random initialization)
+        or 'imagenet' (pre-training on ImageNet).
+        If weights='imagenet' input channels must be equal to 3.
+
+    Returns:
+      An integer shape tuple (may include None entries).
+
+    Raises:
+      ValueError: In case of invalid argument values.
+    """
+    if weights != "imagenet" and input_shape and len(input_shape) == 3:
+        if data_format == "channels_first":
+            correct_channel_axis = 1 if len(input_shape) == 4 else 0
+            if input_shape[correct_channel_axis] not in {1, 3}:
+                warnings.warn(
+                    "This model usually expects 1 or 3 input channels. "
+                    "However, it was passed an input_shape "
+                    f"with {input_shape[0]} input channels.",
+                    stacklevel=2,
+                )
+            default_shape = (input_shape[0], default_size, default_size)
+        else:
+            if input_shape[-1] not in {1, 3}:
+                warnings.warn(
+                    "This model usually expects 1 or 3 input channels. "
+                    "However, it was passed an input_shape "
+                    f"with {input_shape[-1]} input channels.",
+                    stacklevel=2,
+                )
+            default_shape = (default_size, default_size, input_shape[-1])
+    else:
+        if data_format == "channels_first":
+            default_shape = (3, default_size, default_size)
+        else:
+            default_shape = (default_size, default_size, 3)
+    if weights == "imagenet" and require_flatten:
+        if input_shape is not None:
+            if input_shape != default_shape:
+                raise ValueError(
+                    "When setting `include_top=True` "
+                    "and loading `imagenet` weights, "
+                    f"`input_shape` should be {default_shape}.  "
+                    f"Received: input_shape={input_shape}"
+                )
+        return default_shape
+    if input_shape:
+        if data_format == "channels_first":
+            if input_shape is not None:
+                if len(input_shape) != 3:
+                    raise ValueError("`input_shape` must be a tuple of three integers.")
+                if input_shape[0] != 3 and weights == "imagenet":
+                    raise ValueError(
+                        "The input must have 3 channels; Received "
+                        f"`input_shape={input_shape}`"
+                    )
+                if (input_shape[1] is not None and input_shape[1] < min_size) or (
+                    input_shape[2] is not None and input_shape[2] < min_size
+                ):
+                    raise ValueError(
+                        f"Input size must be at least {min_size}"
+                        f"x{min_size}; Received: "
+                        f"input_shape={input_shape}"
+                    )
+        else:
+            if input_shape is not None:
+                if len(input_shape) != 3:
+                    raise ValueError("`input_shape` must be a tuple of three integers.")
+                if input_shape[-1] != 3 and weights == "imagenet":
+                    raise ValueError(
+                        "The input must have 3 channels; Received "
+                        f"`input_shape={input_shape}`"
+                    )
+                if (input_shape[0] is not None and input_shape[0] < min_size) or (
+                    input_shape[1] is not None and input_shape[1] < min_size
+                ):
+                    raise ValueError(
+                        "Input size must be at least "
+                        f"{min_size}x{min_size}; Received: "
+                        f"input_shape={input_shape}"
+                    )
+    else:
+        if require_flatten:
+            input_shape = default_shape
+        else:
+            if data_format == "channels_first":
+                input_shape = (3, None, None)
+            else:
+                input_shape = (None, None, 3)
+    if require_flatten:
+        if None in input_shape:
+            raise ValueError(
+                "If `include_top` is True, "
+                "you should specify a static `input_shape`. "
+                f"Received: input_shape={input_shape}"
+            )
+    return input_shape

{segmodels_keras-0.1.0.dev7 → segmodels_keras-0.1.0.dev8}/segmodels_keras.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev7
+Version: 0.1.0.dev8
 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.dev7 → segmodels_keras-0.1.0.dev8}/segmodels_keras.egg-info/SOURCES.txt

@@ -20,7 +20,8 @@ segmodels_keras/backbones/_weights.py
 segmodels_keras/backbones/backbones_factory.py
 segmodels_keras/backbones/inception_resnet_v2.py
 segmodels_keras/backbones/inception_v3.py
-segmodels_keras/backbones/resnet.py
+segmodels_keras/backbones/resnet_18_34.py
+segmodels_keras/backbones/resnet_common.py
 segmodels_keras/base/__init__.py
 segmodels_keras/base/functional.py
 segmodels_keras/base/objects.py

segmodels_keras-0.1.0.dev7/segmodels_keras/backbones/resnet.py

@@ -1,494 +0,0 @@
-"""Resnet keras models.
-
-Source: https://github.com/qubvel/classification_models
-"""
-
-import collections
-import os
-
-from keras import backend, layers, models
-from keras.utils import get_source_inputs
-
-from ._common_blocks import ChannelSE
-from ._weights import load_model_weights
-
-ModelParams = collections.namedtuple(
-    "ModelParams", ["model_name", "repetitions", "residual_block", "attention"]
-)
-
-BASE_WEIGHT_URL = (
-    "https://github.com/qubvel/classification_models/releases/download/0.0.1/"
-)
-
-# -------------------------------------------------------------------------
-#   Helpers functions
-# -------------------------------------------------------------------------
-
-
-def handle_block_names(stage, block):
-    name_base = f"stage{stage + 1}_unit{block + 1}_"
-    conv_name = name_base + "conv"
-    bn_name = name_base + "bn"
-    relu_name = name_base + "relu"
-    sc_name = name_base + "sc"
-    return conv_name, bn_name, relu_name, sc_name
-
-
-def get_conv_params(**params):
-    default_conv_params = {
-        "kernel_initializer": "he_uniform",
-        "use_bias": False,
-        "padding": "valid",
-    }
-    default_conv_params.update(params)
-    return default_conv_params
-
-
-def get_bn_params(**params):
-    axis = 3 if backend.image_data_format() == "channels_last" else 1
-    default_bn_params = {
-        "axis": axis,
-        "momentum": 0.99,
-        "epsilon": 2e-5,
-        "center": True,
-        "scale": True,
-    }
-    default_bn_params.update(params)
-    return default_bn_params
-
-
-# -------------------------------------------------------------------------
-#   Residual blocks
-# -------------------------------------------------------------------------
-
-
-def residual_conv_block(
-    filters, stage, block, strides=(1, 1), attention=None, cut="pre"
-):
-    """The identity block is the block that has no conv layer at shortcut.
-    # Arguments
-        input_tensor: input tensor
-        kernel_size: default 3, the kernel size of
-            middle conv layer at main path
-        filters: list of integers, the filters of 3 conv layer at main path
-        stage: integer, current stage label, used for generating layer names
-        block: 'a','b'..., current block label, used for generating layer names
-        cut: one of 'pre', 'post'. used to decide where skip connection is taken
-    # Returns
-        Output tensor for the block.
-    """
-
-    def layer(input_tensor):
-
-        # get params and names of layers
-        conv_params = get_conv_params()
-        bn_params = get_bn_params()
-        conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
-
-        x = layers.BatchNormalization(name=bn_name + "1", **bn_params)(input_tensor)
-        x = layers.Activation("relu", name=relu_name + "1")(x)
-
-        # defining shortcut connection
-        if cut == "pre":
-            shortcut = input_tensor
-        elif cut == "post":
-            shortcut = layers.Conv2D(
-                filters, (1, 1), name=sc_name, strides=strides, **conv_params
-            )(x)
-        else:
-            raise ValueError('Cut type not in ["pre", "post"]')
-
-        # continue with convolution layers
-        x = layers.ZeroPadding2D(padding=(1, 1))(x)
-        x = layers.Conv2D(
-            filters, (3, 3), strides=strides, name=conv_name + "1", **conv_params
-        )(x)
-
-        x = layers.BatchNormalization(name=bn_name + "2", **bn_params)(x)
-        x = layers.Activation("relu", name=relu_name + "2")(x)
-        x = layers.ZeroPadding2D(padding=(1, 1))(x)
-        x = layers.Conv2D(filters, (3, 3), name=conv_name + "2", **conv_params)(x)
-
-        # use attention block if defined
-        if attention is not None:
-            x = attention(x)
-
-        # add residual connection
-        x = layers.Add()([x, shortcut])
-        return x
-
-    return layer
-
-
-def residual_bottleneck_block(
-    filters, stage, block, strides=None, attention=None, cut="pre"
-):
-    """The identity block is the block that has no conv layer at shortcut.
-    # Arguments
-        input_tensor: input tensor
-        kernel_size: default 3, the kernel size of
-            middle conv layer at main path
-        filters: list of integers, the filters of 3 conv layer at main path
-        stage: integer, current stage label, used for generating layer names
-        block: 'a','b'..., current block label, used for generating layer names
-        cut: one of 'pre', 'post'. used to decide where skip connection is taken
-    # Returns
-        Output tensor for the block.
-    """
-
-    def layer(input_tensor):
-
-        # get params and names of layers
-        conv_params = get_conv_params()
-        bn_params = get_bn_params()
-        conv_name, bn_name, relu_name, sc_name = handle_block_names(stage, block)
-
-        x = layers.BatchNormalization(name=bn_name + "1", **bn_params)(input_tensor)
-        x = layers.Activation("relu", name=relu_name + "1")(x)
-
-        # defining shortcut connection
-        if cut == "pre":
-            shortcut = input_tensor
-        elif cut == "post":
-            shortcut = layers.Conv2D(
-                filters * 4, (1, 1), name=sc_name, strides=strides, **conv_params
-            )(x)
-        else:
-            raise ValueError('Cut type not in ["pre", "post"]')
-
-        # continue with convolution layers
-        x = layers.Conv2D(filters, (1, 1), name=conv_name + "1", **conv_params)(x)
-
-        x = layers.BatchNormalization(name=bn_name + "2", **bn_params)(x)
-        x = layers.Activation("relu", name=relu_name + "2")(x)
-        x = layers.ZeroPadding2D(padding=(1, 1))(x)
-        x = layers.Conv2D(
-            filters, (3, 3), strides=strides, name=conv_name + "2", **conv_params
-        )(x)
-
-        x = layers.BatchNormalization(name=bn_name + "3", **bn_params)(x)
-        x = layers.Activation("relu", name=relu_name + "3")(x)
-        x = layers.Conv2D(filters * 4, (1, 1), name=conv_name + "3", **conv_params)(x)
-
-        # use attention block if defined
-        if attention is not None:
-            x = attention(x)
-
-        # add residual connection
-        x = layers.Add()([x, shortcut])
-
-        return x
-
-    return layer
-
-
-# -------------------------------------------------------------------------
-#   Residual Model Builder
-# -------------------------------------------------------------------------
-
-
-def ResNet(
-    model_params,
-    input_shape=None,
-    input_tensor=None,
-    include_top=True,
-    classes=1000,
-    weights="imagenet",
-    **kwargs,
-):
-    """Instantiates the ResNet, SEResNet 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`.
-
-    Args:
-        include_top: whether to include the fully-connected
-            layer at the top of the network.
-        weights: one of `None` (random initialization),
-              'imagenet' (pre-training on ImageNet),
-              or the path to the weights file to be loaded.
-        input_tensor: optional Keras tensor
-            (i.e. output of `layers.Input()`)
-            to use as image input for the model.
-        input_shape: optional shape tuple, only to be specified
-            if `include_top` is False (otherwise the input shape
-            has to be `(224, 224, 3)` (with `channels_last` data format)
-            or `(3, 224, 224)` (with `channels_first` data format).
-            It should have exactly 3 inputs channels.
-        classes: optional number of classes to classify images
-            into, only to be specified if `include_top` is True, and
-            if no `weights` argument is specified.
-
-    Returns:
-        A Keras model instance.
-
-    Raises:
-        ValueError: in case of invalid argument for `weights`,
-            or invalid input shape.
-    """
-    if input_tensor is None:
-        img_input = layers.Input(shape=input_shape, name="data")
-    else:
-        if not backend.is_keras_tensor(input_tensor):
-            img_input = layers.Input(tensor=input_tensor, shape=input_shape)
-        else:
-            img_input = input_tensor
-
-    # choose residual block type
-    ResidualBlock = model_params.residual_block
-    if model_params.attention:
-        Attention = model_params.attention(**kwargs)
-    else:
-        Attention = None
-
-    # get parameters for model layers
-    no_scale_bn_params = get_bn_params(scale=False)
-    bn_params = get_bn_params()
-    conv_params = get_conv_params()
-    init_filters = 64
-
-    # resnet bottom
-    x = layers.BatchNormalization(name="bn_data", **no_scale_bn_params)(img_input)
-    x = layers.ZeroPadding2D(padding=(3, 3))(x)
-    x = layers.Conv2D(
-        init_filters, (7, 7), strides=(2, 2), name="conv0", **conv_params
-    )(x)
-    x = layers.BatchNormalization(name="bn0", **bn_params)(x)
-    x = layers.Activation("relu", name="relu0")(x)
-    x = layers.ZeroPadding2D(padding=(1, 1))(x)
-    x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding="valid", name="pooling0")(x)
-
-    # resnet body
-    for stage, rep in enumerate(model_params.repetitions):
-        for block in range(rep):
-            filters = init_filters * (2**stage)
-
-            # first block of first stage without strides because we have maxpooling
-            # before
-            if block == 0 and stage == 0:
-                x = ResidualBlock(
-                    filters,
-                    stage,
-                    block,
-                    strides=(1, 1),
-                    cut="post",
-                    attention=Attention,
-                )(x)
-
-            elif block == 0:
-                x = ResidualBlock(
-                    filters,
-                    stage,
-                    block,
-                    strides=(2, 2),
-                    cut="post",
-                    attention=Attention,
-                )(x)
-
-            else:
-                x = ResidualBlock(
-                    filters,
-                    stage,
-                    block,
-                    strides=(1, 1),
-                    cut="pre",
-                    attention=Attention,
-                )(x)
-
-    x = layers.BatchNormalization(name="bn1", **bn_params)(x)
-    x = layers.Activation("relu", name="relu1")(x)
-
-    # resnet top
-    if include_top:
-        x = layers.GlobalAveragePooling2D(name="pool1")(x)
-        x = layers.Dense(classes, name="fc1")(x)
-        x = layers.Activation("softmax", name="softmax")(x)
-
-    # Ensure that the model takes into account any potential predecessors of
-    # `input_tensor`.
-    if input_tensor is not None:
-        inputs = get_source_inputs(input_tensor)
-    else:
-        inputs = img_input
-
-    # Create model.
-    model = models.Model(inputs, x)
-
-    if weights:
-        if isinstance(weights, str) and os.path.exists(weights):
-            model.load_weights(weights)
-        else:
-            load_model_weights(
-                model, model_params.model_name, weights, classes, include_top, **kwargs
-            )
-
-    return model
-
-
-# -------------------------------------------------------------------------
-#   Residual Models
-# -------------------------------------------------------------------------
-
-MODELS_PARAMS = {
-    "resnet18": ModelParams("resnet18", (2, 2, 2, 2), residual_conv_block, None),
-    "resnet34": ModelParams("resnet34", (3, 4, 6, 3), residual_conv_block, None),
-    "resnet50": ModelParams("resnet50", (3, 4, 6, 3), residual_bottleneck_block, None),
-    "resnet101": ModelParams(
-        "resnet101", (3, 4, 23, 3), residual_bottleneck_block, None
-    ),
-    "resnet152": ModelParams(
-        "resnet152", (3, 8, 36, 3), residual_bottleneck_block, None
-    ),
-    "seresnet18": ModelParams(
-        "seresnet18", (2, 2, 2, 2), residual_conv_block, ChannelSE
-    ),
-    "seresnet34": ModelParams(
-        "seresnet34", (3, 4, 6, 3), residual_conv_block, ChannelSE
-    ),
-}
-
-
-def ResNet18(
-    input_shape=None,
-    input_tensor=None,
-    weights=None,
-    classes=1000,
-    include_top=True,
-    **kwargs,
-):
-    return ResNet(
-        MODELS_PARAMS["resnet18"],
-        input_shape=input_shape,
-        input_tensor=input_tensor,
-        include_top=include_top,
-        classes=classes,
-        weights=weights,
-        **kwargs,
-    )
-
-
-def ResNet34(
-    input_shape=None,
-    input_tensor=None,
-    weights=None,
-    classes=1000,
-    include_top=True,
-    **kwargs,
-):
-    return ResNet(
-        MODELS_PARAMS["resnet34"],
-        input_shape=input_shape,
-        input_tensor=input_tensor,
-        include_top=include_top,
-        classes=classes,
-        weights=weights,
-        **kwargs,
-    )
-
-
-def ResNet50(
-    input_shape=None,
-    input_tensor=None,
-    weights=None,
-    classes=1000,
-    include_top=True,
-    **kwargs,
-):
-    return ResNet(
-        MODELS_PARAMS["resnet50"],
-        input_shape=input_shape,
-        input_tensor=input_tensor,
-        include_top=include_top,
-        classes=classes,
-        weights=weights,
-        **kwargs,
-    )
-
-
-def ResNet101(
-    input_shape=None,
-    input_tensor=None,
-    weights=None,
-    classes=1000,
-    include_top=True,
-    **kwargs,
-):
-    return ResNet(
-        MODELS_PARAMS["resnet101"],
-        input_shape=input_shape,
-        input_tensor=input_tensor,
-        include_top=include_top,
-        classes=classes,
-        weights=weights,
-        **kwargs,
-    )
-
-
-def ResNet152(
-    input_shape=None,
-    input_tensor=None,
-    weights=None,
-    classes=1000,
-    include_top=True,
-    **kwargs,
-):
-    return ResNet(
-        MODELS_PARAMS["resnet152"],
-        input_shape=input_shape,
-        input_tensor=input_tensor,
-        include_top=include_top,
-        classes=classes,
-        weights=weights,
-        **kwargs,
-    )
-
-
-def SEResNet18(
-    input_shape=None,
-    input_tensor=None,
-    weights=None,
-    classes=1000,
-    include_top=True,
-    **kwargs,
-):
-    return ResNet(
-        MODELS_PARAMS["seresnet18"],
-        input_shape=input_shape,
-        input_tensor=input_tensor,
-        include_top=include_top,
-        classes=classes,
-        weights=weights,
-        **kwargs,
-    )
-
-
-def SEResNet34(
-    input_shape=None,
-    input_tensor=None,
-    weights=None,
-    classes=1000,
-    include_top=True,
-    **kwargs,
-):
-    return ResNet(
-        MODELS_PARAMS["seresnet34"],
-        input_shape=input_shape,
-        input_tensor=input_tensor,
-        include_top=include_top,
-        classes=classes,
-        weights=weights,
-        **kwargs,
-    )
-
-
-def preprocess_input(x, **kwargs):  # noqa: ARG001
-    return x
-
-
-ResNet18.__doc__ = ResNet.__doc__
-ResNet34.__doc__ = ResNet.__doc__
-ResNet50.__doc__ = ResNet.__doc__
-ResNet101.__doc__ = ResNet.__doc__
-ResNet152.__doc__ = ResNet.__doc__
-SEResNet18.__doc__ = ResNet.__doc__
-SEResNet34.__doc__ = ResNet.__doc__