careamics 0.0.19__py3-none-any.whl

careamics/utils/path_utils.py

@@ -0,0 +1,26 @@
+"""Utility functions for paths."""
+
+from pathlib import Path
+from typing import Union
+
+
+def check_path_exists(path: Union[str, Path]) -> Path:
+    """Check if a path exists. If not, raise an error.
+
+    Note that it returns `path` as a Path object.
+
+    Parameters
+    ----------
+    path : Union[str, Path]
+        Path to check.
+
+    Returns
+    -------
+    Path
+        Path as a Path object.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Data path {path} is incorrect or does not exist.")
+
+    return path

careamics/utils/plotting.py

@@ -0,0 +1,76 @@
+"""Plotting utilities."""
+
+import matplotlib.pyplot as plt
+import numpy as np
+import torch
+from numpy.typing import NDArray
+
+from careamics.models.lvae.noise_models import GaussianMixtureNoiseModel
+
+
+def plot_noise_model_probability_distribution(
+    noise_model: GaussianMixtureNoiseModel,
+    signalBinIndex: int,
+    histogram: NDArray,
+    channel: str | None = None,
+    number_of_bins: int = 100,
+) -> None:
+    """Plot probability distribution P(x|s) for a certain ground truth signal.
+
+    Predictions from both Histogram and GMM-based
+    Noise models are displayed for comparison.
+
+    Parameters
+    ----------
+    noise_model : GaussianMixtureNoiseModel
+        Trained GaussianMixtureNoiseModel.
+    signalBinIndex : int
+        Index of signal bin. Values go from 0 to number of bins (`n_bin`).
+    histogram : NDArray
+        Histogram based noise model.
+    channel : Optional[str], optional
+        Channel name used for plotting. Default is None.
+    number_of_bins : int, optional
+        Number of bins in the resulting histogram. Default is 100.
+    """
+    min_signal = noise_model.min_signal.item()
+    max_signal = noise_model.max_signal.item()
+    bin_size = (max_signal - min_signal) / number_of_bins
+
+    query_signal_normalized = signalBinIndex / number_of_bins
+    query_signal = query_signal_normalized * (max_signal - min_signal) + min_signal
+    query_signal += bin_size / 2
+    query_signal = torch.tensor(query_signal)
+
+    query_observations = torch.arange(min_signal, max_signal, bin_size)
+    query_observations += bin_size / 2
+
+    likelihoods = noise_model.likelihood(
+        observations=query_observations, signals=query_signal
+    ).numpy()
+
+    plt.figure(figsize=(12, 5))
+    if channel:
+        plt.suptitle(f"Noise model for channel {channel}")
+    else:
+        plt.suptitle("Noise model")
+
+    plt.subplot(1, 2, 1)
+    plt.xlabel("Observation Bin")
+    plt.ylabel("Signal Bin")
+    plt.imshow(histogram**0.25, cmap="gray")
+    plt.axhline(y=signalBinIndex + 0.5, linewidth=5, color="blue", alpha=0.5)
+
+    plt.subplot(1, 2, 2)
+    plt.plot(
+        query_observations,
+        likelihoods,
+        label="GMM : " + " signal = " + str(np.round(query_signal, 2)),
+        marker=".",
+        color="red",
+        linewidth=2,
+    )
+    plt.xlabel("Observations (x) for signal s = " + str(query_signal))
+    plt.ylabel("Probability Density")
+    plt.title("Probability Distribution P(x|s) at signal =" + str(query_signal))
+    plt.legend()

careamics/utils/ram.py

@@ -0,0 +1,15 @@
+"""Utility function to get RAM size."""
+
+import psutil
+
+
+def get_ram_size() -> int:
+    """
+    Get RAM size in mbytes.
+
+    Returns
+    -------
+    int
+        RAM size in mbytes.
+    """
+    return psutil.virtual_memory().available / 1024**2

careamics/utils/receptive_field.py

@@ -0,0 +1,108 @@
+"""Receptive field calculation for computing the tile overlap."""
+
+# TODO better docstring and function names
+# Adapted from: https://github.com/frgfm/torch-scan
+
+# import math
+# import warnings
+# from typing import Tuple, Union
+
+# from torch import Tensor, nn
+# from torch.nn import Module
+# from torch.nn.modules.batchnorm import _BatchNorm
+# from torch.nn.modules.conv import _ConvNd, _ConvTransposeNd
+# from torch.nn.modules.pooling import (
+#     _AdaptiveAvgPoolNd,
+#     _AdaptiveMaxPoolNd,
+#     _AvgPoolNd,
+#     _MaxPoolNd,
+# )
+
+
+# def module_rf(module: Module, inp: Tensor, out: Tensor) -> Tuple[float, float, float]:
+#     """Estimate the spatial receptive field of the module.
+
+#     Parameters
+#     ----------
+#     module : Module
+#         Module to estimate the receptive field.
+#     inp : Tensor
+#         Input tensor.
+#     out : Tensor
+#         Output tensor.
+
+#     Returns
+#     -------
+#     Tuple[float, float, float]
+#         Receptive field, effective stride and padding.
+#     """
+#     if isinstance(
+#         module,
+#         (
+#             nn.Identity,
+#             nn.Flatten,
+#             nn.ReLU,
+#             nn.ELU,
+#             nn.LeakyReLU,
+#             nn.ReLU6,
+#             nn.Tanh,
+#             nn.Sigmoid,
+#             _BatchNorm,
+#             nn.Dropout,
+#             nn.Linear,
+#         ),
+#     ):
+#         return 1.0, 1.0, 0.0
+#     elif isinstance(module, _ConvTransposeNd):
+#         return rf_convtransposend(module, inp, out)
+#     elif isinstance(module, (_ConvNd, _MaxPoolNd, _AvgPoolNd)):
+#         return rf_aggregnd(module, inp, out)
+#     elif isinstance(module, (_AdaptiveMaxPoolNd, _AdaptiveAvgPoolNd)):
+#         return rf_adaptive_poolnd(module, inp, out)
+#     else:
+#         warnings.warn(
+#             f"Module type not supported: {module.__class__.__name__}", stacklevel=1
+#         )
+#         return 1.0, 1.0, 0.0
+
+
+# def rf_convtransposend(
+#     module: _ConvTransposeNd, _: Tensor, __: Tensor
+# ) -> Tuple[float, float, float]:
+#     k = (
+#         module.kernel_size[0]
+#         if isinstance(module.kernel_size, tuple)
+#         else module.kernel_size
+#     )
+#     s = module.stride[0] if isinstance(module.stride, tuple) else module.stride
+#     return -k, 1.0 / s, 0.0
+
+
+# def rf_aggregnd(
+#     module: Union[_ConvNd, _MaxPoolNd, _AvgPoolNd], _: Tensor, __: Tensor
+# ) -> Tuple[float, float, float]:
+#     k = (
+#         module.kernel_size[0]
+#         if isinstance(module.kernel_size, tuple)
+#         else module.kernel_size
+#     )
+#     if hasattr(module, "dilation"):
+#         d = (
+#             module.dilation[0]
+#             if isinstance(module.dilation, tuple)
+#             else module.dilation
+#         )
+#         k = d * (k - 1) + 1
+#     s = module.stride[0] if isinstance(module.stride, tuple) else module.stride
+#     p = module.padding[0] if isinstance(module.padding, tuple) else module.padding
+#     return k, s, p  # type: ignore[return-value]
+
+
+# def rf_adaptive_poolnd(
+#     _: Union[_AdaptiveMaxPoolNd, _AdaptiveAvgPoolNd], inp: Tensor, out: Tensor
+# ) -> Tuple[int, int, float]:
+#     stride = math.ceil(inp.shape[-1] / out.shape[-1])
+#     kernel_size = stride
+#     padding = (inp.shape[-1] - kernel_size * stride) / 2
+
+#     return kernel_size, stride, padding

careamics/utils/serializers.py

@@ -0,0 +1,62 @@
+"""A script for serializers in the careamics package."""
+
+import ast
+import json
+from typing import Union
+
+import numpy as np
+import torch
+
+
+def _array_to_json(arr: Union[np.ndarray, torch.Tensor]) -> str:
+    """Convert an array to a list and then to a JSON string.
+
+    Parameters
+    ----------
+    arr : Union[np.ndarray, torch.Tensor]
+        Array to be serialized.
+
+    Returns
+    -------
+    str
+        JSON string representing the array.
+    """
+    if isinstance(arr, str):
+        return arr
+    return json.dumps(arr.tolist())
+
+
+def _to_numpy(lst: Union[str, list]) -> np.ndarray:
+    """Deserialize a list or string representing a list into `np.ndarray`.
+
+    Parameters
+    ----------
+    lst : list
+        List or string representing a list with the array content to be deserialized.
+
+    Returns
+    -------
+    np.ndarray
+        The deserialized array.
+    """
+    if isinstance(lst, str):
+        lst = ast.literal_eval(lst)
+    return np.asarray(lst)
+
+
+def _to_torch(lst: Union[str, list]) -> torch.Tensor:
+    """Deserialize list or string representing a list into `torch.Tensor`.
+
+    Parameters
+    ----------
+    lst : Union[str, list]
+        List or string representing a list swith the array content to be deserialized.
+
+    Returns
+    -------
+    torch.Tensor
+        The deserialized tensor.
+    """
+    if isinstance(lst, str):
+        lst = ast.literal_eval(lst)
+    return torch.tensor(lst)

careamics/utils/torch_utils.py

@@ -0,0 +1,150 @@
+"""
+Convenience functions using torch.
+
+These functions are used to control certain aspects and behaviours of PyTorch.
+"""
+
+import inspect
+import platform
+from typing import Union
+
+import torch
+
+from careamics.config.support import SupportedOptimizer, SupportedScheduler
+
+from ..utils.logging import get_logger
+
+logger = get_logger(__name__)  # TODO are logger still needed?
+
+
+def get_device() -> str:
+    """
+    Get the device on which operations take place.
+
+    Returns
+    -------
+    str
+        The device on which operations take place, e.g. "cuda", "cpu" or "mps".
+    """
+    if torch.cuda.is_available():
+        device = "cuda"
+    elif torch.backends.mps.is_available() and platform.processor() in (
+        "arm",
+        "arm64",
+    ):
+        device = "mps"
+    else:
+        device = "cpu"
+
+    return device
+
+
+def filter_parameters(
+    func: type,
+    user_params: dict,
+) -> dict:
+    """
+    Filter parameters according to the function signature.
+
+    Parameters
+    ----------
+    func : type
+        Class object.
+    user_params : dict
+        User provided parameters.
+
+    Returns
+    -------
+    dict
+        Parameters matching `func`'s signature.
+    """
+    # Get the list of all default parameters
+    default_params = list(inspect.signature(func).parameters.keys())
+
+    # Filter matching parameters
+    params_to_be_used = set(user_params.keys()) & set(default_params)
+
+    return {key: user_params[key] for key in params_to_be_used}
+
+
+def get_optimizer(name: str) -> torch.optim.Optimizer:
+    """
+    Return the optimizer class given its name.
+
+    Parameters
+    ----------
+    name : str
+        Optimizer name.
+
+    Returns
+    -------
+    torch.nn.Optimizer
+        Optimizer class.
+    """
+    if name not in SupportedOptimizer:
+        raise NotImplementedError(f"Optimizer {name} is not yet supported.")
+
+    return getattr(torch.optim, name)
+
+
+def get_optimizers() -> dict[str, str]:
+    """
+    Return the list of all optimizers available in torch.optim.
+
+    Returns
+    -------
+    dict
+        Optimizers available in torch.optim.
+    """
+    optims = {}
+    for name, obj in inspect.getmembers(torch.optim):
+        if inspect.isclass(obj) and issubclass(obj, torch.optim.Optimizer):
+            if name != "Optimizer":
+                optims[name] = name
+    return optims
+
+
+def get_scheduler(
+    name: str,
+) -> Union[
+    # torch.optim.lr_scheduler.LRScheduler,
+    torch.optim.lr_scheduler.ReduceLROnPlateau,
+]:
+    """
+    Return the scheduler class given its name.
+
+    Parameters
+    ----------
+    name : str
+        Scheduler name.
+
+    Returns
+    -------
+    Union
+        Scheduler class.
+    """
+    if name not in SupportedScheduler:
+        raise NotImplementedError(f"Scheduler {name} is not yet supported.")
+
+    return getattr(torch.optim.lr_scheduler, name)
+
+
+def get_schedulers() -> dict[str, str]:
+    """
+    Return the list of all schedulers available in torch.optim.lr_scheduler.
+
+    Returns
+    -------
+    dict
+        Schedulers available in torch.optim.lr_scheduler.
+    """
+    schedulers = {}
+    for name, obj in inspect.getmembers(torch.optim.lr_scheduler):
+        if inspect.isclass(obj) and issubclass(
+            obj, torch.optim.lr_scheduler.LRScheduler
+        ):
+            if "LRScheduler" not in name:
+                schedulers[name] = name
+        elif name == "ReduceLROnPlateau":  # somewhat not a subclass of LRScheduler
+            schedulers[name] = name
+    return schedulers

careamics/utils/version.py

@@ -0,0 +1,38 @@
+"""Version utility."""
+
+import logging
+
+from careamics import __version__
+
+logger = logging.getLogger(__name__)
+
+
+def get_careamics_version() -> str:
+    """Get clean CAREamics version.
+
+    This method returns the latest `Major.Minor.Patch` version of CAREamics, removing
+    any local version identifier.
+
+    Returns
+    -------
+    str
+        Clean CAREamics version.
+    """
+    parts = __version__.split(".")
+
+    # for local installs that do not detect the latest versions via tags
+    # (typically our CI will install `0.X.devX<hash>.<other hash>` versions)
+    if "dev" in parts[2]:
+        parts[2] = "*"
+        clean_version = ".".join(parts[:3])
+
+        logger.warning(
+            f"Your CAREamics version seems to be a locally modified version "
+            f"({__version__}). The recorded version for loading models will be "
+            f"{clean_version}, which may not exist. If you want to ensure "
+            f"exporting the model with an existing version, please install the "
+            f"closest CAREamics version from PyPI or conda-forge."
+        )
+
+    # Remove any local version identifier
+    return ".".join(parts[:3])

careamics-0.0.19.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: careamics
+Version: 0.0.19
+Summary: Toolbox for running N2V and friends.
+Project-URL: homepage, https://careamics.github.io/
+Project-URL: repository, https://github.com/CAREamics/careamics
+Author-email: CAREamics team <rse@fht.org>, Ashesh <ashesh.ashesh@fht.org>, Federico Carrara <federico.carrara@fht.org>, Melisande Croft <melisande.croft@fht.org>, Joran Deschamps <joran.deschamps@fht.org>, Vera Galinova <vera.galinova@fht.org>, Igor Zubarev <igor.zubarev@fht.org>
+License: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: bioimageio-core>=0.9.0
+Requires-Dist: matplotlib<=3.10.8
+Requires-Dist: numpy>=1.21
+Requires-Dist: numpy>=2.1.0; python_version >= '3.13'
+Requires-Dist: pillow<=12.1.0
+Requires-Dist: psutil<=7.2.1
+Requires-Dist: pydantic<=2.12.5,>=2.11
+Requires-Dist: pytorch-lightning<=2.6.0,>=2.2
+Requires-Dist: pyyaml!=6.0.0,<=6.0.3
+Requires-Dist: scikit-image<=0.26.0
+Requires-Dist: tifffile<=2025.12.20
+Requires-Dist: torch<=2.9.1,>=2.0
+Requires-Dist: torchmetrics<1.5.0,>=0.11.0
+Requires-Dist: torchvision<=0.24.1
+Requires-Dist: typer<=0.21.1,>=0.12.3
+Requires-Dist: validators<=0.35.0
+Requires-Dist: zarr<4.0.0,>=3.0.0
+Provides-Extra: czi
+Requires-Dist: pylibczirw<6.0.0,>=4.1.2; extra == 'czi'
+Provides-Extra: examples
+Requires-Dist: careamics-portfolio; extra == 'examples'
+Requires-Dist: jupyter; extra == 'examples'
+Provides-Extra: tensorboard
+Requires-Dist: protobuf==5.29.1; extra == 'tensorboard'
+Requires-Dist: tensorboard; extra == 'tensorboard'
+Provides-Extra: wandb
+Requires-Dist: wandb; extra == 'wandb'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://careamics.github.io/">
+    <img src="https://raw.githubusercontent.com/CAREamics/.github/main/profile/images/banner_careamics.png">
+  </a>
+</p>
+
+# CAREamics
+
+[![License](https://img.shields.io/pypi/l/careamics.svg?color=green)](https://github.com/CAREamics/careamics/blob/main/LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/careamics.svg?color=green)](https://pypi.org/project/careamics)
+[![Python Version](https://img.shields.io/pypi/pyversions/careamics.svg?color=green)](https://python.org)
+[![CI](https://github.com/CAREamics/careamics/actions/workflows/ci.yml/badge.svg)](https://github.com/CAREamics/careamics/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/CAREamics/careamics/branch/main/graph/badge.svg)](https://codecov.io/gh/CAREamics/careamics)
+[![Image.sc](https://img.shields.io/badge/Got%20a%20question%3F-Image.sc-blue)](https://forum.image.sc/)
+
+
+CAREamics is a PyTorch library aimed at simplifying the use of Noise2Void and its many
+variants and cousins (CARE, Noise2Noise, N2V2, P(P)N2V, HDN, muSplit etc.).
+
+## Why CAREamics?
+
+Noise2Void is a widely used denoising algorithm, and is readily available from the `n2v`
+python package. However, `n2v` is based on TensorFlow, while more recent methods 
+denoising methods (PPN2V, DivNoising, HDN) are all implemented in PyTorch, but are 
+lacking the extra features that would make them usable by the community.
+
+The aim of CAREamics is to provide a PyTorch library reuniting all the latest methods
+in one package, while providing a simple and consistent API. The library relies on 
+PyTorch Lightning as a back-end. In addition, we will provide extensive documentation and 
+tutorials on how to best apply these methods in a scientific context.
+
+## Installation and use
+
+Check out the [documentation](https://careamics.github.io/) for installation instructions and guides!