segmodels-keras 0.1.0__tar.gz

segmodels_keras-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2018, Pavel Yakubovskiy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

segmodels_keras-0.1.0/MANIFEST.in

@@ -0,0 +1 @@
+include README.md LICENSE requirements.txt

segmodels_keras-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: segmodels_keras
+Version: 0.1.0
+Summary: Image segmentation models with pre-trained backbones with Keras.
+Home-page: https://github.com/orthoseg/segmodels_keras
+Author: Pieter Roggemans
+Author-email: pieter.roggemans@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+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"
+Requires-Dist: scikit-image; extra == "tests"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Image segmentation models with pre-trained backbones with Keras.

segmodels_keras-0.1.0/README.rst

@@ -0,0 +1,58 @@
+|Actions Status| |Code coverage| |PyPI version|
+
+.. |Actions Status| image:: https://github.com/orthoseg/segmodels_keras/actions/workflows/tests.yml/badge.svg?branch=main
+   :target: https://github.com/orthoseg/segmodels_keras/actions/workflows/tests.yml?query=workflow%3ATests
+
+.. |Code coverage| image:: https://codecov.io/gh/orthoseg/segmodels_keras/graph/badge.svg?token=o01OyTMDuj 
+   :target: https://codecov.io/gh/orthoseg/segmodels_keras
+
+.. |PyPI version| image:: https://img.shields.io/pypi/v/segmodels-keras.svg
+   :target: https://pypi.org/project/segmodels-keras
+
+
+###############
+segmodels_keras
+###############
+
+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 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:
+
+- 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/pyproject.toml

@@ -0,0 +1,68 @@
+[[tool.mypy.overrides]]
+module = "h5py.*,keras.*,six.*,setuptools.*,sphinx_rtd_theme.*,tensorflow.*"
+ignore_missing_imports = true
+
+[tool.pyright]
+exclude = ["local_ignore", "**/node_modules", "**/__pycache__", "**/.*"]
+ignore = ["*"]
+
+[tool.pytest.ini_options]
+log_level = "DEBUG"
+# Write all logging and warnings immediately while running test with debugger.
+# log_cli = true
+# addopts = "-p no:warnings"
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+extend-exclude = ["docs/conf.py", "local_ignore/*", "examples"]
+
+[tool.ruff.lint]
+select = [
+    "YTT",  # flake8-2020
+    # "ANN",  # flake8-annotations
+    "B",  # flake8-bugbear
+    "A",  # flake8-builtins
+    "C4",  # flake8-comprehensions
+    "T10",  # flake8-debugger
+    "ISC",  # flake8-implicit string concatenation
+    # "G",  # flake8-logging-format
+    "PIE",  # flake8-pie misc lints
+    # "SIM",  # flake8-simplify
+    "TC",  # flake8-type-checking imports
+    "ARG",  # flake8-unused-arguments
+    # "PTH",  # flake8-use-pathlib
+    "FLY",  # flynt
+    "I",  # isort
+    "NPY",  # NumPy-specific rules
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "D",  # pydocstyle
+    "F",  # pyflakes
+    "PLC",  # pylint convention
+    "PLE",  # pylint error
+    "PLR",  # pylint refactor
+    "PLW",  # pylint warning
+    "UP",  # pyupgrade
+    "RUF",  # Ruff-specific rules
+]
+
+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
+    "PLR2004",  # Magic number
+    "PLR5501",  # Use `elif` instead of `else` then `if`, to reduce indentation
+    "PLW2901",  # Loop variable overwritten by assignment target
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["ANN", "D"]
+"perftests/*" = ["ANN", "D"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"

segmodels_keras-0.1.0/segmodels_keras/__init__.py

@@ -0,0 +1,141 @@
+"""Segmentation Models for Keras."""
+
+import functools  # noqa: I001
+import os
+from typing import Any
+from collections.abc import Callable
+
+# __version__ should be defined as soon as possible
+from ._version import __version__
+
+from . import base
+
+_KERAS_FRAMEWORK_NAME: str = "keras"
+_TF_KERAS_FRAMEWORK_NAME: str = "tf.keras"
+
+_DEFAULT_KERAS_FRAMEWORK: str = _KERAS_FRAMEWORK_NAME
+_KERAS_FRAMEWORK: str | None = None
+_KERAS_BACKEND: Any = None
+_KERAS_LAYERS: Any = None
+_KERAS_MODELS: Any = None
+_KERAS_UTILS: Any = None
+_KERAS_LOSSES: Any = None
+
+
+def inject_global_losses(func: Callable[..., Any]) -> Callable[..., Any]:
+    @functools.wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        kwargs["losses"] = _KERAS_LOSSES
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+def filter_kwargs(func: Callable[..., Any]) -> Callable[..., Any]:
+    @functools.wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        new_kwargs = {
+            k: v
+            for k, v in kwargs.items()
+            if k in ["backend", "layers", "models", "utils"]
+        }
+        return func(*args, **new_kwargs)
+
+    return wrapper
+
+
+def framework() -> str | None:
+    """Return name of Segmentation Models framework."""
+    return _KERAS_FRAMEWORK
+
+
+def set_framework(name: str) -> None:
+    """Set framework for Segmentation Models.
+
+    Args:
+        name (str): one of ``keras``, ``tf.keras``, case insensitive.
+
+    Raises:
+        ValueError: in case of incorrect framework name.
+        ImportError: in case framework is not installed.
+
+    """
+    name = name.lower()
+
+    if name == _KERAS_FRAMEWORK_NAME:
+        import keras  # noqa: PLC0415
+    elif name == _TF_KERAS_FRAMEWORK_NAME:
+        from tensorflow import keras  # noqa: PLC0415
+    else:
+        raise ValueError(
+            f"Not correct module name `{name}`, use `{_KERAS_FRAMEWORK_NAME}` or "
+            f"`{_TF_KERAS_FRAMEWORK_NAME}`"
+        )
+
+    global _KERAS_BACKEND, _KERAS_LAYERS, _KERAS_MODELS  # noqa: PLW0603
+    global _KERAS_UTILS, _KERAS_LOSSES, _KERAS_FRAMEWORK  # noqa: PLW0603
+
+    _KERAS_FRAMEWORK = name
+    _KERAS_BACKEND = keras.backend
+    _KERAS_LAYERS = keras.layers
+    _KERAS_MODELS = keras.models
+    _KERAS_UTILS = keras.utils
+    _KERAS_LOSSES = keras.losses
+
+    # allow losses/metrics get keras submodules
+    base.KerasObject.set_submodules(
+        backend=keras.backend,
+        layers=keras.layers,
+        models=keras.models,
+        utils=keras.utils,
+    )
+
+
+# set default framework
+_framework = os.environ.get("SM_FRAMEWORK", _DEFAULT_KERAS_FRAMEWORK)
+try:
+    set_framework(_framework)
+except ImportError:
+    other = (
+        _TF_KERAS_FRAMEWORK_NAME
+        if _framework == _KERAS_FRAMEWORK_NAME
+        else _KERAS_FRAMEWORK_NAME
+    )
+    set_framework(other)
+
+print(f"Segmentation Models: using `{_KERAS_FRAMEWORK}` framework.")
+
+# import helper modules
+from . import losses, metrics, utils
+
+# wrap segmentation models with framework modules
+from .backbones.backbones_factory import Backbones
+from .models.fpn import FPN
+from .models.linknet import Linknet
+from .models.model_factory import get_model
+from .models.pspnet import PSPNet
+from .models.unet import Unet
+
+get_available_backbone_names = Backbones.models_names
+
+
+def get_preprocessing(name: str) -> Callable[[Any], Any]:
+    """Get the preprocessing function for a backbone by name."""
+    return Backbones.get_preprocessing(name)
+
+
+__all__ = [
+    "FPN",
+    "Linknet",
+    "PSPNet",
+    "Unet",
+    "__version__",
+    "framework",
+    "get_available_backbone_names",
+    "get_model",
+    "get_preprocessing",
+    "losses",
+    "metrics",
+    "set_framework",
+    "utils",
+]

segmodels_keras-0.1.0/segmodels_keras/_compat.py

@@ -0,0 +1,6 @@
+"""Compatibility utilities for Keras 3 and legacy Keras 2."""
+
+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/segmodels_keras/_version.py

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

segmodels_keras-0.1.0/segmodels_keras/backbones/__init__.py

@@ -0,0 +1 @@
+"""Backbones package."""

segmodels_keras-0.1.0/segmodels_keras/backbones/_common_blocks.py

@@ -0,0 +1,134 @@
+"""Common blocks for backbone models.
+
+Source: https://github.com/qubvel/classification_models
+"""
+
+from keras import backend, layers
+
+
+def slice_tensor(x, start, stop, axis):
+    if axis == 3:
+        return x[:, :, :, start:stop]
+    elif axis == 1:
+        return x[:, start:stop, :, :]
+    else:
+        raise ValueError(f"Slice axis should be in (1, 3), got {axis}.")
+
+
+def GroupConv2D(
+    filters,
+    kernel_size,
+    strides=(1, 1),
+    groups=32,
+    kernel_initializer="he_uniform",
+    use_bias=True,
+    activation="linear",
+    padding="valid",
+    **kwargs,  # noqa: ARG001
+):
+    """Grouped Convolution Layer implemented as a Slice, Conv2D and Concatenate layers.
+
+    Split filters to groups, apply Conv2D and concatenate back.
+
+    Args:
+        filters: Integer, the dimensionality of the output space
+            (i.e. the number of output filters in the convolution).
+        kernel_size: An integer or tuple/list of a single integer,
+            specifying the length of the 1D convolution window.
+        strides: An integer or tuple/list of a single integer, specifying the stride
+            length of the convolution.
+        groups: Integer, number of groups to split input filters to.
+        kernel_initializer: Regularizer function applied to the kernel weights matrix.
+        use_bias: Boolean, whether the layer uses a bias vector.
+        activation: Activation function to use (see activations).
+            If you don't specify anything, no activation is applied
+            (ie. "linear" activation: a(x) = x).
+        padding: one of "valid" or "same" (case-insensitive).
+        kwargs: additional keyword arguments (unused).
+
+    Input shape:
+        4D tensor with shape: (batch, rows, cols, channels) if data_format is
+        "channels_last".
+
+    Output shape:
+        4D tensor with shape: (batch, new_rows, new_cols, filters) if data_format is
+        "channels_last". rows and cols values might have changed due to padding.
+
+    """
+    slice_axis = 3 if backend.image_data_format() == "channels_last" else 1
+
+    def layer(input_tensor):
+        inp_ch = int(
+            backend.int_shape(input_tensor)[-1] // groups
+        )  # input grouped channels
+        out_ch = int(filters // groups)  # output grouped channels
+
+        blocks = []
+        for c in range(groups):
+            slice_arguments = {
+                "start": c * inp_ch,
+                "stop": (c + 1) * inp_ch,
+                "axis": slice_axis,
+            }
+            x = layers.Lambda(slice_tensor, arguments=slice_arguments)(input_tensor)
+            x = layers.Conv2D(
+                out_ch,
+                kernel_size,
+                strides=strides,
+                kernel_initializer=kernel_initializer,
+                use_bias=use_bias,
+                activation=activation,
+                padding=padding,
+            )(x)
+            blocks.append(x)
+
+        x = layers.Concatenate(axis=slice_axis)(blocks)
+        return x
+
+    return layer
+
+
+def expand_dims(x, channels_axis):
+    if channels_axis == 3:
+        return x[:, None, None, :]
+    elif channels_axis == 1:
+        return x[:, :, None, None]
+    else:
+        raise ValueError(f"Slice axis should be in (1, 3), got {channels_axis}.")
+
+
+def ChannelSE(reduction=16, **kwargs):  # noqa: ARG001
+    """Squeeze and Excitation block.
+
+    Reimplementation inspired by
+    https://github.com/Cadene/pretrained-models.pytorch/blob/master/pretrainedmodels/models/senet.py.
+
+    Args:
+        reduction: channels squeeze factor
+        kwargs: additional keyword arguments (unused).
+
+    """
+    channels_axis = 3 if backend.image_data_format() == "channels_last" else 1
+
+    def layer(input_tensor):
+        # get number of channels/filters
+        channels = backend.int_shape(input_tensor)[channels_axis]
+
+        x = input_tensor
+
+        # squeeze and excitation block in PyTorch style with
+        x = layers.GlobalAveragePooling2D()(x)
+        x = layers.Lambda(expand_dims, arguments={"channels_axis": channels_axis})(x)
+        x = layers.Conv2D(
+            channels // reduction, (1, 1), kernel_initializer="he_uniform"
+        )(x)
+        x = layers.Activation("relu")(x)
+        x = layers.Conv2D(channels, (1, 1), kernel_initializer="he_uniform")(x)
+        x = layers.Activation("sigmoid")(x)
+
+        # apply attention
+        x = layers.Multiply()([input_tensor, x])
+
+        return x
+
+    return layer