segmodels-keras 0.1.0.dev0__tar.gz → 0.1.0.dev2__tar.gz

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev0
+Version: 0.1.0.dev2
 Summary: Image segmentation models with pre-trained backbones with Keras.
-Home-page: https://github.com/theroggy/segmodels_keras
+Home-page: https://github.com/orthoseg/segmodels_keras
 Author: Pieter Roggemans
 Author-email: pieter.roggemans@gmail.com
 License: MIT
@@ -15,6 +15,7 @@ Requires-Python: >=3.0.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: keras
+Requires-Dist: packaging
 Provides-Extra: tests
 Requires-Dist: numpy; extra == "tests"
 Requires-Dist: pytest; extra == "tests"

segmodels_keras-0.1.0.dev2/README.rst

@@ -0,0 +1,53 @@
+|Actions Status| |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
+
+.. |PyPI version| image:: https://img.shields.io/pypi/v/segmodels-keras.svg
+   :target: https://pypi.org/project/segmodels-keras
+
+
+###############
+segmodels_keras
+###############
+
+This is a fork of the
+`segmentation_models <https://github.com/qubvel/segmentation_models>`__ library by
+Pavel Iakubovskii, which is not maintained anymore.
+
+This fork is updated to support Keras 3, and also contains some bug fixes, some
+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.
+
+
+**The main features** of this library are:
+
+- High level API (just two lines of code to create model for segmentation)
+- **4** models architectures for binary and multi-class image segmentation
+  (including legendary **Unet**)
+- **20+** available backbones for each architecture
+- All backbones have **pre-trained** weights for faster and better convergence
+- Helpful segmentation losses (Jaccard, Dice, Focal) and metrics (IoU, F-score)
+
+Documentation
+~~~~~~~~~~~~~
+The **documentation** of the current stable version is available here:
+`Read the docs, stable <https://segmodels_keras.readthedocs.io/en/stable/>`__.
+
+The lastest version of the documentation (= of the main branch) can be found here:
+`Read the docs, latest <https://segmodels_keras.readthedocs.io/en/latest/>`__.
+
+Change Log
+~~~~~~~~~~
+To see important changes between versions look at CHANGELOG.md_
+
+License
+~~~~~~~
+Project is distributed under `MIT Licence`_.
+
+.. _CHANGELOG.md: https://github.com/orthoseg/segmodels_keras/blob/main/CHANGELOG.md
+.. _`MIT Licence`: https://github.com/orthoseg/segmodels_keras/blob/main/LICENSE

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/segmodels_keras/__init__.py

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

segmodels_keras-0.1.0.dev2/segmodels_keras/_compat.py

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

segmodels_keras-0.1.0.dev2/segmodels_keras/_version.py

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

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/segmodels_keras/backbones/backbones_factory.py

@@ -125,7 +125,14 @@ class BackbonesFactory:
         "inceptionresnetv2": (
             irv2.InceptionResNetV2,
             irv2.preprocess_input,
-            (594, 260, 16, 9),
+            (
+                "activation_161",
+                "activation_74",
+                "activation_3",
+                "activation",
+                # "input_1",
+            ),
+            # (594, 260, 16, 9),
         ),
         "inceptionv3": (iv3.InceptionV3, iv3.preprocess_input, (228, 86, 16, 9)),
         # MobileNet

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/segmodels_keras/backbones/inception_resnet_v2.py

@@ -1,166 +1,49 @@
 """Inception-ResNet V2 model for Keras.
+
 Model naming and structure follows TF-slim implementation
 (which has some additional layers and different number of
 filters from the original arXiv paper):
 https://github.com/tensorflow/models/blob/master/research/slim/nets/inception_resnet_v2.py
+
 Pre-trained ImageNet weights are also converted from TF-slim,
 which can be found in:
 https://github.com/tensorflow/models/tree/master/research/slim#pre-trained-models
+
 # Reference
 - [Inception-v4, Inception-ResNet and the Impact of
    Residual Connections on Learning](https://arxiv.org/abs/1602.07261) (AAAI 2017)
+
+Differences with the original implementation in keras.applications:
+- For e.g. in the `conv2d_bn` blocks, padding="same" is used instead of "valid". This is
+  to make the sizes of the outputs of the layers the correct size for the skip
+  connections for the decoders in the segmentation models. It does not affect the
+  weights of the layers, so we can still use the pre-trained weights from the original
+  implementation.
+  An alternative solution is to add a padding layer before the skip connections, but
+  that would add extra parameters to the model, which we want to avoid as that might
+  also give issues when loading weights that were saved with an older version. An
+  example where this solution is used/shown can be found here:
+  https://github.com/ayushdabra/dubai-satellite-imagery-segmentation/blob/9446e16134e752dda080ba9d65be18ea47fa26a9/get_activations.py#L40
+- The original implementation uses different imports as it is internal in keras, and
+  here we need to use the public API of keras.
+- Use Lambda layer instead of CustomScaleLayer because:
+    - it avoids having to define + pass in a custom layer when loading the model
+    - otherwise "old" weights cannot be loaded when using keras 3
 """
 
-import os
 import warnings
+from pathlib import Path
 
 from keras import backend, layers, models
-from keras import utils as keras_utils
 from keras.applications import imagenet_utils
+from keras.layers import Layer
+from keras.utils import get_file, get_source_inputs
 
 BASE_WEIGHT_URL = (
-    "https://github.com/fchollet/deep-learning-models/releases/download/v0.7/"
+    "https://storage.googleapis.com/tensorflow/keras-applications/inception_resnet_v2/"
 )
 
 
-def preprocess_input(x, **kwargs):
-    """Preprocesses a numpy array encoding a batch of images.
-    # Arguments
-        x: a 4D numpy array consists of RGB values within [0, 255].
-    # Returns
-        Preprocessed array.
-    """
-    return imagenet_utils.preprocess_input(x, mode="tf", **kwargs)
-
-
-def conv2d_bn(
-    x,
-    filters,
-    kernel_size,
-    strides=1,
-    padding="same",
-    activation="relu",
-    use_bias=False,
-    name=None,
-):
-    """Utility function to apply conv + BN.
-    # Arguments
-        x: input tensor.
-        filters: filters in `Conv2D`.
-        kernel_size: kernel size as in `Conv2D`.
-        strides: strides in `Conv2D`.
-        padding: padding mode in `Conv2D`.
-        activation: activation in `Conv2D`.
-        use_bias: whether to use a bias in `Conv2D`.
-        name: name of the ops; will become `name + '_ac'` for the activation
-            and `name + '_bn'` for the batch norm layer.
-    # Returns
-        Output tensor after applying `Conv2D` and `BatchNormalization`.
-    """
-    x = layers.Conv2D(
-        filters,
-        kernel_size,
-        strides=strides,
-        padding=padding,
-        use_bias=use_bias,
-        name=name,
-    )(x)
-    if not use_bias:
-        bn_axis = 1 if backend.image_data_format() == "channels_first" else 3
-        bn_name = None if name is None else name + "_bn"
-        x = layers.BatchNormalization(axis=bn_axis, scale=False, name=bn_name)(x)
-    if activation is not None:
-        ac_name = None if name is None else name + "_ac"
-        x = layers.Activation(activation, name=ac_name)(x)
-    return x
-
-
-def inception_resnet_block(x, scale, block_type, block_idx, activation="relu"):
-    """Adds a Inception-ResNet block.
-    This function builds 3 types of Inception-ResNet blocks mentioned
-    in the paper, controlled by the `block_type` argument (which is the
-    block name used in the official TF-slim implementation):
-        - Inception-ResNet-A: `block_type='block35'`
-        - Inception-ResNet-B: `block_type='block17'`
-        - Inception-ResNet-C: `block_type='block8'`
-    # Arguments
-        x: input tensor.
-        scale: scaling factor to scale the residuals (i.e., the output of
-            passing `x` through an inception module) before adding them
-            to the shortcut branch.
-            Let `r` be the output from the residual branch,
-            the output of this block will be `x + scale * r`.
-        block_type: `'block35'`, `'block17'` or `'block8'`, determines
-            the network structure in the residual branch.
-        block_idx: an `int` used for generating layer names.
-            The Inception-ResNet blocks
-            are repeated many times in this network.
-            We use `block_idx` to identify
-            each of the repetitions. For example,
-            the first Inception-ResNet-A block
-            will have `block_type='block35', block_idx=0`,
-            and the layer names will have
-            a common prefix `'block35_0'`.
-        activation: activation function to use at the end of the block
-            (see [activations](../activations.md)).
-            When `activation=None`, no activation is applied
-            (i.e., "linear" activation: `a(x) = x`).
-    # Returns
-        Output tensor for the block.
-    # Raises
-        ValueError: if `block_type` is not one of `'block35'`,
-            `'block17'` or `'block8'`.
-    """
-    if block_type == "block35":
-        branch_0 = conv2d_bn(x, 32, 1)
-        branch_1 = conv2d_bn(x, 32, 1)
-        branch_1 = conv2d_bn(branch_1, 32, 3)
-        branch_2 = conv2d_bn(x, 32, 1)
-        branch_2 = conv2d_bn(branch_2, 48, 3)
-        branch_2 = conv2d_bn(branch_2, 64, 3)
-        branches = [branch_0, branch_1, branch_2]
-    elif block_type == "block17":
-        branch_0 = conv2d_bn(x, 192, 1)
-        branch_1 = conv2d_bn(x, 128, 1)
-        branch_1 = conv2d_bn(branch_1, 160, [1, 7])
-        branch_1 = conv2d_bn(branch_1, 192, [7, 1])
-        branches = [branch_0, branch_1]
-    elif block_type == "block8":
-        branch_0 = conv2d_bn(x, 192, 1)
-        branch_1 = conv2d_bn(x, 192, 1)
-        branch_1 = conv2d_bn(branch_1, 224, [1, 3])
-        branch_1 = conv2d_bn(branch_1, 256, [3, 1])
-        branches = [branch_0, branch_1]
-    else:
-        raise ValueError(
-            "Unknown Inception-ResNet block type. "
-            'Expects "block35", "block17" or "block8", '
-            "but got: " + str(block_type)
-        )
-
-    block_name = block_type + "_" + str(block_idx)
-    channel_axis = 1 if backend.image_data_format() == "channels_first" else 3
-    mixed = layers.Concatenate(axis=channel_axis, name=block_name + "_mixed")(branches)
-    up = conv2d_bn(
-        mixed,
-        x.shape[channel_axis],
-        1,
-        activation=None,
-        use_bias=True,
-        name=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])
-    if activation is not None:
-        x = layers.Activation(activation, name=block_name + "_ac")(x)
-    return x
-
-
 def InceptionResNetV2(
     include_top=True,
     weights="imagenet",
@@ -168,23 +51,47 @@ def InceptionResNetV2(
     input_shape=None,
     pooling=None,
     classes=1000,
-    **kwargs,  # noqa: ARG001
+    classifier_activation="softmax",
+    name="inception_resnet_v2",
 ):
     """Instantiates the Inception-ResNet v2 architecture.
-    Optionally loads weights pre-trained on ImageNet.
-    Note that the data format convention used by the model is
-    the one specified in your Keras config at `~/.keras/keras.json`.
-    # Arguments
+
+    Reference:
+    - [Inception-v4, Inception-ResNet and the Impact of
+       Residual Connections on Learning](https://arxiv.org/abs/1602.07261)
+      (AAAI 2017)
+
+    This function returns a Keras image classification model,
+    optionally loaded with weights pre-trained on ImageNet.
+
+    For image classification use cases, see
+    [this page for detailed examples](
+      https://keras.io/api/applications/#usage-examples-for-image-classification-models).
+
+    For transfer learning use cases, make sure to read the
+    [guide to transfer learning & fine-tuning](
+      https://keras.io/guides/transfer_learning/).
+
+    Note: each Keras Application expects a specific kind of
+    input preprocessing. For InceptionResNetV2, call
+    `keras.applications.inception_resnet_v2.preprocess_input`
+    on your inputs before passing them to the model.
+    `inception_resnet_v2.preprocess_input`
+    will scale input pixels between -1 and 1.
+
+    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()`)
+            `"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 `(299, 299, 3)` (with `'channels_last'` data format)
+            has to be `(299, 299, 3)`
+            (with `'channels_last'` data format)
             or `(3, 299, 299)` (with `'channels_first'` data format).
             It should have exactly 3 inputs channels,
             and width and height should be no smaller than 75.
@@ -199,15 +106,20 @@ def InceptionResNetV2(
                 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.
-    # Returns
-        A Keras `Model` instance.
-    # Raises
-        ValueError: in case of invalid argument for `weights`,
-            or invalid input shape.
+            into, only to be specified if `include_top` is `True`,
+            and if no `weights` argument is specified.
+        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"`.
+        name: The name of the model (string).
+
+    Returns:
+        A model instance.
     """
-    if not (weights in {"imagenet", None} or os.path.exists(weights)):
+    if not (weights in {"imagenet", None} or Path(weights).exists()):
         raise ValueError(
             "The `weights` argument should be either "
             "`None` (random initialization), `imagenet` "
@@ -217,8 +129,9 @@ def InceptionResNetV2(
 
     if weights == "imagenet" and include_top and classes != 1000:
         raise ValueError(
-            'If using `weights` as `"imagenet"` with `include_top`'
-            " as true, `classes` should be 1000"
+            'If using `weights="imagenet"` with `include_top=True`, '
+            "`classes` should be 1000. "
+            f"Received classes={classes}"
         )
 
     # Determine proper input shape
@@ -233,10 +146,11 @@ def InceptionResNetV2(
 
     if input_tensor is None:
         img_input = layers.Input(shape=input_shape)
-    elif not backend.is_keras_tensor(input_tensor):
-        img_input = layers.Input(tensor=input_tensor, shape=input_shape)
     else:
-        img_input = input_tensor
+        if not backend.is_keras_tensor(input_tensor):
+            img_input = layers.Input(tensor=input_tensor, shape=input_shape)
+        else:
+            img_input = input_tensor
 
     # Stem block: 35 x 35 x 192
     x = conv2d_bn(img_input, 32, 3, strides=2, padding="same")
@@ -308,27 +222,31 @@ def InceptionResNetV2(
     if include_top:
         # Classification block
         x = layers.GlobalAveragePooling2D(name="avg_pool")(x)
-        x = layers.Dense(classes, activation="softmax", name="predictions")(x)
-    elif pooling == "avg":
-        x = layers.GlobalAveragePooling2D()(x)
-    elif pooling == "max":
-        x = layers.GlobalMaxPooling2D()(x)
+        imagenet_utils.validate_activation(classifier_activation, weights)
+        x = layers.Dense(classes, activation=classifier_activation, name="predictions")(
+            x
+        )
+    else:
+        if pooling == "avg":
+            x = layers.GlobalAveragePooling2D()(x)
+        elif pooling == "max":
+            x = layers.GlobalMaxPooling2D()(x)
 
     # Ensure that the model takes into account
     # any potential predecessors of `input_tensor`.
     if input_tensor is not None:
-        inputs = keras_utils.get_source_inputs(input_tensor)
+        inputs = get_source_inputs(input_tensor)
     else:
         inputs = img_input
 
     # Create model.
-    model = models.Model(inputs, x, name="inception_resnet_v2")
+    model = models.Model(inputs, x, name=name)
 
     # Load weights.
     if weights == "imagenet":
         if include_top:
             fname = "inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5"
-            weights_path = keras_utils.get_file(
+            weights_path = get_file(
                 fname,
                 BASE_WEIGHT_URL + fname,
                 cache_subdir="models",
@@ -336,7 +254,7 @@ def InceptionResNetV2(
             )
         else:
             fname = "inception_resnet_v2_weights_tf_dim_ordering_tf_kernels_notop.h5"
-            weights_path = keras_utils.get_file(
+            weights_path = get_file(
                 fname,
                 BASE_WEIGHT_URL + fname,
                 cache_subdir="models",
@@ -349,46 +267,216 @@ def InceptionResNetV2(
     return model
 
 
-def _obtain_input_shape(
-    input_shape, default_size, min_size, data_format, require_flatten, weights=None
+def conv2d_bn(
+    x,
+    filters,
+    kernel_size,
+    strides=1,
+    padding="same",
+    activation="relu",
+    use_bias=False,
+    name=None,
 ):
-    """Internal utility to compute/validate a model's input shape.
+    """Utility function to apply conv + BN.
 
-    # Arguments
-        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.
+    Args:
+        x: input tensor.
+        filters: filters in `Conv2D`.
+        kernel_size: kernel size as in `Conv2D`.
+        strides: strides in `Conv2D`.
+        padding: padding mode in `Conv2D`.
+        activation: activation in `Conv2D`.
+        use_bias: whether to use a bias in `Conv2D`.
+        name: name of the ops; will become `name + '_ac'`
+            for the activation and `name + '_bn'` for the batch norm layer.
 
-    # Returns
-        An integer shape tuple (may include None entries).
+    Returns:
+        Output tensor after applying `Conv2D` and `BatchNormalization`.
+    """
+    x = layers.Conv2D(
+        filters,
+        kernel_size,
+        strides=strides,
+        padding=padding,
+        use_bias=use_bias,
+        name=name,
+    )(x)
+    if not use_bias:
+        bn_axis = 1 if backend.image_data_format() == "channels_first" else 3
+        bn_name = None if name is None else f"{name}_bn"
+        x = layers.BatchNormalization(axis=bn_axis, scale=False, name=bn_name)(x)
+    if activation is not None:
+        ac_name = None if name is None else f"{name}_ac"
+        x = layers.Activation(activation, name=ac_name)(x)
+    return x
+
+
+def inception_resnet_block(x, scale, block_type, block_idx, activation="relu"):
+    """Adds a Inception-ResNet block.
 
+    This function builds 3 types of Inception-ResNet blocks mentioned
+    in the paper, controlled by the `block_type` argument (which is the
+    block name used in the official TF-slim implementation):
+        - Inception-ResNet-A: `block_type='block35'`
+        - Inception-ResNet-B: `block_type='block17'`
+        - Inception-ResNet-C: `block_type='block8'`
+
+    Args:
+        x: input tensor.
+        scale: scaling factor to scale the residuals
+            (i.e., the output of passing `x` through an inception module)
+            before adding them to the shortcut
+            branch. Let `r` be the output from the residual branch,
+            the output of this block will be `x + scale * r`.
+        block_type: `'block35'`, `'block17'` or `'block8'`,
+            determines the network structure in the residual branch.
+        block_idx: an `int` used for generating layer names.
+            The Inception-ResNet blocks are repeated many times
+            in this network. We use `block_idx` to identify each
+            of the repetitions. For example, the first
+            Inception-ResNet-A block will have
+            `block_type='block35', block_idx=0`, and the layer names
+            will have a common prefix `'block35_0'`.
+        activation: activation function to use at the end of the block.
+            (see [activations](../activations.md)).
+            When `activation=None`, no activation is applied
+            (i.e., "linear" activation: `a(x) = x`).
+    # Returns
+        Output tensor for the block.
     # Raises
-        ValueError: In case of invalid argument values.
+        ValueError: if `block_type` is not one of `'block35'`,
+            `'block17'` or `'block8'`.
+        Output tensor for the block.
+    """
+    if block_type == "block35":
+        branch_0 = conv2d_bn(x, 32, 1)
+        branch_1 = conv2d_bn(x, 32, 1)
+        branch_1 = conv2d_bn(branch_1, 32, 3)
+        branch_2 = conv2d_bn(x, 32, 1)
+        branch_2 = conv2d_bn(branch_2, 48, 3)
+        branch_2 = conv2d_bn(branch_2, 64, 3)
+        branches = [branch_0, branch_1, branch_2]
+    elif block_type == "block17":
+        branch_0 = conv2d_bn(x, 192, 1)
+        branch_1 = conv2d_bn(x, 128, 1)
+        branch_1 = conv2d_bn(branch_1, 160, [1, 7])
+        branch_1 = conv2d_bn(branch_1, 192, [7, 1])
+        branches = [branch_0, branch_1]
+    elif block_type == "block8":
+        branch_0 = conv2d_bn(x, 192, 1)
+        branch_1 = conv2d_bn(x, 192, 1)
+        branch_1 = conv2d_bn(branch_1, 224, [1, 3])
+        branch_1 = conv2d_bn(branch_1, 256, [3, 1])
+        branches = [branch_0, branch_1]
+    else:
+        raise ValueError(
+            "Unknown Inception-ResNet block type. "
+            'Expects "block35", "block17" or "block8", '
+            f"but got: {block_type}"
+        )
+
+    block_name = f"{block_type}_{block_idx}"
+    channel_axis = 1 if backend.image_data_format() == "channels_first" else 3
+    mixed = layers.Concatenate(axis=channel_axis, name=f"{block_name}_mixed")(branches)
+    up = conv2d_bn(
+        mixed,
+        x.shape[channel_axis],
+        1,
+        activation=None,
+        use_bias=True,
+        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])
+
+    if activation is not None:
+        x = layers.Activation(activation, name=f"{block_name}_ac")(x)
+
+    return x
+
+
+def preprocess_input(x, data_format=None):
+    """Preprocesses a numpy array encoding a batch of images.
+
+    Args:
+        x: a 4D numpy array consists of RGB values within [0, 255].
+
+    Returns:
+        Preprocessed array.
+    """
+    return imagenet_utils.preprocess_input(x, data_format=data_format, mode="tf")
+
+
+def decode_predictions(preds, top=5):
+    """Decodes the prediction of an ImageNet model.
+
+    Args:
+        preds: NumPy array encoding a batch of predictions.
+        top: Integer, how many top-guesses to return. Defaults to `5`.
+
+    Returns:
+        A list of lists of top class prediction tuples
+        `(class_name, class_description, score)`.
+        One list of tuples per sample in batch input.
+
+    Raises:
+        ValueError: In case of invalid shape of the `pred` array
+            (must be 2D).
+    """
+    return imagenet_utils.decode_predictions(preds, top=top)
+
+
+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":
-            if input_shape[0] not in {1, 3}:
-                warnings.warn(  # noqa: B028
+            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 with "
-                    + str(input_shape[0])
-                    + " 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(  # noqa: B028
+                warnings.warn(
                     "This model usually expects 1 or 3 input channels. "
-                    "However, it was passed an input_shape with "
-                    + str(input_shape[-1])
-                    + " 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:
@@ -402,7 +490,8 @@ def _obtain_input_shape(
                 raise ValueError(
                     "When setting `include_top=True` "
                     "and loading `imagenet` weights, "
-                    "`input_shape` should be " + str(default_shape) + "."
+                    f"`input_shape` should be {default_shape}.  "
+                    f"Received: input_shape={input_shape}"
                 )
         return default_shape
     if input_shape:
@@ -412,20 +501,16 @@ def _obtain_input_shape(
                     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; got "
-                        "`input_shape=" + str(input_shape) + "`"
+                        "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(
-                        "Input size must be at least "
-                        + str(min_size)
-                        + "x"
-                        + str(min_size)
-                        + "; got `input_shape="
-                        + str(input_shape)
-                        + "`"
+                        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:
@@ -433,20 +518,16 @@ def _obtain_input_shape(
                     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; got "
-                        "`input_shape=" + str(input_shape) + "`"
+                        "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 "
-                        + str(min_size)
-                        + "x"
-                        + str(min_size)
-                        + "; got `input_shape="
-                        + str(input_shape)
-                        + "`"
+                        f"{min_size}x{min_size}; Received: "
+                        f"input_shape={input_shape}"
                     )
     else:
         if require_flatten:
@@ -461,6 +542,6 @@ def _obtain_input_shape(
             raise ValueError(
                 "If `include_top` is True, "
                 "you should specify a static `input_shape`. "
-                "Got `input_shape=" + str(input_shape) + "`"
+                f"Received: input_shape={input_shape}"
             )
     return input_shape

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/segmodels_keras/base/functional.py

@@ -1,7 +1,8 @@
+import keras
+
 from segmodels_keras._compat import KERAS_GTE_3
 
 if KERAS_GTE_3:
-    import keras
     from keras import ops
 else:
     from keras import backend as ops

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/segmodels_keras.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: segmodels_keras
-Version: 0.1.0.dev0
+Version: 0.1.0.dev2
 Summary: Image segmentation models with pre-trained backbones with Keras.
-Home-page: https://github.com/theroggy/segmodels_keras
+Home-page: https://github.com/orthoseg/segmodels_keras
 Author: Pieter Roggemans
 Author-email: pieter.roggemans@gmail.com
 License: MIT
@@ -15,6 +15,7 @@ Requires-Python: >=3.0.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: keras
+Requires-Dist: packaging
 Provides-Extra: tests
 Requires-Dist: numpy; extra == "tests"
 Requires-Dist: pytest; extra == "tests"

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/segmodels_keras.egg-info/SOURCES.txt

@@ -4,8 +4,8 @@ README.rst
 pyproject.toml
 setup.py
 segmodels_keras/__init__.py
-segmodels_keras/__version__.py
 segmodels_keras/_compat.py
+segmodels_keras/_version.py
 segmodels_keras/losses.py
 segmodels_keras/metrics.py
 segmodels_keras/utils.py

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/segmodels_keras.egg-info/requires.txt

@@ -1,4 +1,5 @@
 keras
+packaging
 
 [tests]
 numpy

{segmodels_keras-0.1.0.dev0 → segmodels_keras-0.1.0.dev2}/setup.py

@@ -10,7 +10,7 @@ from setuptools import find_packages, setup
 # Package meta-data.
 NAME = "segmodels_keras"
 DESCRIPTION = "Image segmentation models with pre-trained backbones with Keras."
-URL = "https://github.com/theroggy/segmodels_keras"
+URL = "https://github.com/orthoseg/segmodels_keras"
 EMAIL = "pieter.roggemans@gmail.com"
 AUTHOR = "Pieter Roggemans"
 REQUIRES_PYTHON = ">=3.0.0"
@@ -24,7 +24,7 @@ VERSION = None
 here = os.path.abspath(os.path.dirname(__file__))
 
 # What packages are required for this module to be executed?
-REQUIRED = ["keras"]
+REQUIRED = ["keras", "packaging"]
 
 # What packages are optional?
 EXTRAS = {
@@ -39,10 +39,10 @@ try:
 except FileNotFoundError:
     long_description = DESCRIPTION
 
-# Load the package's __version__.py module as a dictionary.
+# Load the package's _version.py module as a dictionary.
 about = {}
 if not VERSION:
-    with open(os.path.join(here, NAME, "__version__.py")) as f:
+    with open(os.path.join(here, NAME, "_version.py")) as f:
         exec(f.read(), about)
 else:
     about["__version__"] = VERSION

segmodels_keras-0.1.0.dev0/README.rst

@@ -1,260 +0,0 @@
-segmodels_keras
-=========================
-
-This is a fork of the
-[segmentation_models](https://github.com/qubvel/segmentation_models) library by
-Pavel Iakubovskii, which is not maintained anymore.
-
-This fork is updated to support latest versions of Keras and TensorFlow, and also
-contains some bug fixes and improvements.
-
-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, backwards compatibility,... is not guaranteed or even an explicit goal.
-
-
-**The main features** of this library are:
-
--  High level API (just two lines of code to create model for segmentation)
--  **4** models architectures for binary and multi-class image segmentation
-   (including legendary **Unet**)
--  **25** available backbones for each architecture
--  All backbones have **pre-trained** weights for faster and better
-   convergence
-- Helpful segmentation losses (Jaccard, Dice, Focal) and metrics (IoU, F-score)
-
-
-Table of Contents
-~~~~~~~~~~~~~~~~~
- - `Quick start`_
- - `Simple training pipeline`_
- - `Examples`_
- - `Models and Backbones`_
- - `Installation`_
- - `Documentation`_
- - `Change log`_
- - `Citing`_
- - `License`_
- 
-Quick start
-~~~~~~~~~~~
-Library is build to work together with Keras and TensorFlow Keras frameworks
-
-.. code:: python
-
-    import segmentation_models as sm
-    # Segmentation Models: using `keras` framework.
-
-By default it tries to import ``keras``, if it is not installed, it will try to start with ``tensorflow.keras`` framework.
-There are several ways to choose framework:
-
-- Provide environment variable ``SM_FRAMEWORK=keras`` / ``SM_FRAMEWORK=tf.keras`` before import ``segmentation_models``
-- Change framework ``sm.set_framework('keras')`` /  ``sm.set_framework('tf.keras')``
-
-You can also specify what kind of ``image_data_format`` to use, segmentation-models works with both: ``channels_last`` and ``channels_first``.
-This can be useful for further model conversion to Nvidia TensorRT format or optimizing model for cpu/gpu computations.
-
-.. code:: python
-
-    import keras
-    # or from tensorflow import keras
-
-    keras.backend.set_image_data_format('channels_last')
-    # or keras.backend.set_image_data_format('channels_first')
-
-Created segmentation model is just an instance of Keras Model, which can be build as easy as:
-
-.. code:: python
-    
-    model = sm.Unet()
-    
-Depending on the task, you can change the network architecture by choosing backbones with fewer or more parameters and use pretrainded weights to initialize it:
-
-.. code:: python
-
-    model = sm.Unet('resnet34', encoder_weights='imagenet')
-
-Change number of output classes in the model (choose your case):
-
-.. code:: python
-    
-    # binary segmentation (this parameters are default when you call Unet('resnet34')
-    model = sm.Unet('resnet34', classes=1, activation='sigmoid')
-    
-.. code:: python
-    
-    # multiclass segmentation with non overlapping class masks (your classes + background)
-    model = sm.Unet('resnet34', classes=3, activation='softmax')
-    
-.. code:: python
-    
-    # multiclass segmentation with independent overlapping/non-overlapping class masks
-    model = sm.Unet('resnet34', classes=3, activation='sigmoid')
-    
-    
-Change input shape of the model:
-
-.. code:: python
-    
-    # if you set input channels not equal to 3, you have to set encoder_weights=None
-    # how to handle such case with encoder_weights='imagenet' described in docs
-    model = Unet('resnet34', input_shape=(None, None, 6), encoder_weights=None)
-   
-Simple training pipeline
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. code:: python
-
-    import segmentation_models as sm
-
-    BACKBONE = 'resnet34'
-    preprocess_input = sm.get_preprocessing(BACKBONE)
-
-    # load your data
-    x_train, y_train, x_val, y_val = load_data(...)
-
-    # preprocess input
-    x_train = preprocess_input(x_train)
-    x_val = preprocess_input(x_val)
-
-    # define model
-    model = sm.Unet(BACKBONE, encoder_weights='imagenet')
-    model.compile(
-        'Adam',
-        loss=sm.losses.bce_jaccard_loss,
-        metrics=[sm.metrics.iou_score],
-    )
-
-    # fit model
-    # if you use data generator use model.fit_generator(...) instead of model.fit(...)
-    # more about `fit_generator` here: https://keras.io/models/sequential/#fit_generator
-    model.fit(
-       x=x_train,
-       y=y_train,
-       batch_size=16,
-       epochs=100,
-       validation_data=(x_val, y_val),
-    )
-
-Same manipulations can be done with ``Linknet``, ``PSPNet`` and ``FPN``. For more detailed information about models API and  use cases `Read the Docs <https://segmentation-models.readthedocs.io/en/latest/>`__.
-
-Examples
-~~~~~~~~
-Models training examples:
- - [Jupyter Notebook] Binary segmentation (`cars`) on CamVid dataset `here <https://github.com/qubvel/segmentation_models/blob/master/examples/binary%20segmentation%20(camvid).ipynb>`__.
- - [Jupyter Notebook] Multi-class segmentation (`cars`, `pedestrians`) on CamVid dataset `here <https://github.com/qubvel/segmentation_models/blob/master/examples/multiclass%20segmentation%20(camvid).ipynb>`__.
-
-Models and Backbones
-~~~~~~~~~~~~~~~~~~~~
-**Models**
-
--  `Unet <https://arxiv.org/abs/1505.04597>`__
--  `FPN <http://presentations.cocodataset.org/COCO17-Stuff-FAIR.pdf>`__
--  `Linknet <https://arxiv.org/abs/1707.03718>`__
--  `PSPNet <https://arxiv.org/abs/1612.01105>`__
-
-============= ==============
-Unet          Linknet
-============= ==============
-|unet_image|  |linknet_image|
-============= ==============
-
-============= ==============
-PSPNet        FPN
-============= ==============
-|psp_image|   |fpn_image|
-============= ==============
-
-.. _Unet: https://github.com/qubvel/segmentation_models/blob/readme/LICENSE
-.. _Linknet: https://arxiv.org/abs/1707.03718
-.. _PSPNet: https://arxiv.org/abs/1612.01105
-.. _FPN: http://presentations.cocodataset.org/COCO17-Stuff-FAIR.pdf
-
-.. |unet_image| image:: https://github.com/qubvel/segmentation_models/blob/master/images/unet.png
-.. |linknet_image| image:: https://github.com/qubvel/segmentation_models/blob/master/images/linknet.png
-.. |psp_image| image:: https://github.com/qubvel/segmentation_models/blob/master/images/pspnet.png
-.. |fpn_image| image:: https://github.com/qubvel/segmentation_models/blob/master/images/fpn.png
-
-**Backbones**
-
-.. table:: 
-
-    =============  ===== 
-    Type           Names
-    =============  =====
-    VGG            ``'vgg16' 'vgg19'``
-    ResNet         ``'resnet18' 'resnet34' 'resnet50' 'resnet101' 'resnet152'``
-    SE-ResNet      ``'seresnet18' 'seresnet34' 'seresnet50' 'seresnet101' 'seresnet152'``
-    ResNeXt        ``'resnext50' 'resnext101'``
-    SE-ResNeXt     ``'seresnext50' 'seresnext101'``
-    SENet154       ``'senet154'``
-    DenseNet       ``'densenet121' 'densenet169' 'densenet201'`` 
-    Inception      ``'inceptionv3' 'inceptionresnetv2'``
-    MobileNet      ``'mobilenet' 'mobilenetv2'``
-    EfficientNet   ``'efficientnetb0' 'efficientnetb1' 'efficientnetb2' 'efficientnetb3' 'efficientnetb4' 'efficientnetb5' efficientnetb6' efficientnetb7'``
-    =============  =====
-
-.. epigraph::
-    All backbones have weights trained on 2012 ILSVRC ImageNet dataset (``encoder_weights='imagenet'``). 
-
-
-Installation
-~~~~~~~~~~~~
-
-**Requirements**
-
-1) python 3
-2) keras >= 2.2.0 or tensorflow >= 1.13
-3) keras-applications >= 1.0.7, <=1.0.8
-4) image-classifiers == 1.0.*
-5) efficientnet == 1.0.*
-
-**PyPI stable package**
-
-.. code:: bash
-
-    $ pip install -U segmentation-models
-
-**PyPI latest package**
-
-.. code:: bash
-
-    $ pip install -U --pre segmentation-models
-
-**Source latest version**
-
-.. code:: bash
-
-    $ pip install git+https://github.com/qubvel/segmentation_models
-    
-Documentation
-~~~~~~~~~~~~~
-Latest **documentation** is avaliable on `Read the
-Docs <https://segmentation-models.readthedocs.io/en/latest/>`__
-
-Change Log
-~~~~~~~~~~
-To see important changes between versions look at CHANGELOG.md_
-
-Citing
-~~~~~~~~
-
-.. code::
-
-    @misc{Yakubovskiy:2019,
-      Author = {Pavel Iakubovskii},
-      Title = {Segmentation Models},
-      Year = {2019},
-      Publisher = {GitHub},
-      Journal = {GitHub repository},
-      Howpublished = {\url{https://github.com/qubvel/segmentation_models}}
-    } 
-
-License
-~~~~~~~
-Project is distributed under `MIT Licence`_.
-
-.. _CHANGELOG.md: https://github.com/qubvel/segmentation_models/blob/master/CHANGELOG.md
-.. _`MIT Licence`: https://github.com/qubvel/segmentation_models/blob/master/LICENSE

segmodels_keras-0.1.0.dev0/segmodels_keras/__version__.py

@@ -1,3 +0,0 @@
-VERSION = (0, 1, 0, "dev0")
-
-__version__ = ".".join(map(str, VERSION))

segmodels_keras-0.1.0.dev0/segmodels_keras/_compat.py

@@ -1,3 +0,0 @@
-import keras
-
-KERAS_GTE_3 = keras.__version__ >= "3.0.0"