careamics 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

careamics/utils/metrics.py

@@ -0,0 +1,188 @@
+"""
+Metrics submodule.
+
+This module contains various metrics and a metrics tracking class.
+"""
+
+from typing import Optional, Union
+
+import numpy as np
+import torch
+from skimage.metrics import peak_signal_noise_ratio
+
+
+def psnr(gt: np.ndarray, pred: np.ndarray, range: float = 255.0) -> float:
+    """
+    Peak Signal to Noise Ratio.
+
+    This method calls skimage.metrics.peak_signal_noise_ratio. See:
+    https://scikit-image.org/docs/dev/api/skimage.metrics.html.
+
+    Parameters
+    ----------
+    gt : NumPy array
+        Ground truth image.
+    pred : NumPy array
+        Predicted image.
+    range : float, optional
+        The images pixel range, by default 255.0.
+
+    Returns
+    -------
+    float
+        PSNR value.
+    """
+    return peak_signal_noise_ratio(gt, pred, data_range=range)
+
+
+def _zero_mean(x: np.ndarray) -> np.ndarray:
+    """
+    Zero the mean of an array.
+
+    Parameters
+    ----------
+    x : NumPy array
+        Input array.
+
+    Returns
+    -------
+    NumPy array
+        Zero-mean array.
+    """
+    return x - np.mean(x)
+
+
+def _fix_range(gt: np.ndarray, x: np.ndarray) -> np.ndarray:
+    """
+    Adjust the range of an array based on a reference ground-truth array.
+
+    Parameters
+    ----------
+    gt : np.ndarray
+        Ground truth image.
+    x : np.ndarray
+        Input array.
+
+    Returns
+    -------
+    np.ndarray
+        Range-adjusted array.
+    """
+    a = np.sum(gt * x) / (np.sum(x * x))
+    return x * a
+
+
+def _fix(gt: np.ndarray, x: np.ndarray) -> np.ndarray:
+    """
+    Zero mean a groud truth array and adjust the range of the array.
+
+    Parameters
+    ----------
+    gt : np.ndarray
+        Ground truth image.
+    x : np.ndarray
+        Input array.
+
+    Returns
+    -------
+    np.ndarray
+        Zero-mean and range-adjusted array.
+    """
+    gt_ = _zero_mean(gt)
+    return _fix_range(gt_, _zero_mean(x))
+
+
+def scale_invariant_psnr(
+    gt: np.ndarray, pred: np.ndarray
+) -> Union[float, torch.tensor]:
+    """
+    Scale invariant PSNR.
+
+    Parameters
+    ----------
+    gt : np.ndarray
+        Ground truth image.
+    pred : np.ndarray
+        Predicted image.
+
+    Returns
+    -------
+    Union[float, torch.tensor]
+        Scale invariant PSNR value.
+    """
+    range_parameter = (np.max(gt) - np.min(gt)) / np.std(gt)
+    gt_ = _zero_mean(gt) / np.std(gt)
+    return psnr(_zero_mean(gt_), _fix(gt_, pred), range_parameter)
+
+
+class RunningPSNR:
+    """Compute the running PSNR during validation step in training.
+
+    This class allows to compute the PSNR on the entire validation set
+    one batch at the time.
+
+    Attributes
+    ----------
+    N : int
+        Number of elements seen so far during the epoch.
+    mse_sum : float
+        Running sum of the MSE over the N elements seen so far.
+    max : float
+        Running max value of the N target images seen so far.
+    min : float
+        Running min value of the N target images seen so far.
+    """
+
+    def __init__(self):
+        """Constructor."""
+        self.N = None
+        self.mse_sum = None
+        self.max = self.min = None
+        self.reset()
+
+    def reset(self):
+        """Reset the running PSNR computation.
+
+        Usually called at the end of each epoch.
+        """
+        self.mse_sum = 0
+        self.N = 0
+        self.max = self.min = None
+
+    def update(self, rec: torch.Tensor, tar: torch.Tensor) -> None:
+        """Update the running PSNR statistics given a new batch.
+
+        Parameters
+        ----------
+        rec : torch.Tensor
+            Reconstructed batch.
+        tar : torch.Tensor
+            Target batch.
+        """
+        ins_max = torch.max(tar).item()
+        ins_min = torch.min(tar).item()
+        if self.max is None:
+            assert self.min is None
+            self.max = ins_max
+            self.min = ins_min
+        else:
+            self.max = max(self.max, ins_max)
+            self.min = min(self.min, ins_min)
+
+        mse = (rec - tar) ** 2
+        elementwise_mse = torch.mean(mse.view(len(mse), -1), dim=1)
+        self.mse_sum += torch.nansum(elementwise_mse)
+        self.N += len(elementwise_mse) - torch.sum(torch.isnan(elementwise_mse))
+
+    def get(self) -> Optional[torch.Tensor]:
+        """Get the actual PSNR value given the running statistics.
+
+        Returns
+        -------
+        Optional[torch.Tensor]
+            PSNR value.
+        """
+        if self.N == 0 or self.N is None:
+            return None
+        rmse = torch.sqrt(self.mse_sum / self.N)
+        return 20 * torch.log10((self.max - self.min) / rmse)

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/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/torch_utils.py

@@ -0,0 +1,127 @@
+"""
+Convenience functions using torch.
+
+These functions are used to control certain aspects and behaviours of PyTorch.
+"""
+
+import inspect
+from typing import Dict, 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 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-0.0.3.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.3
+Name: careamics
+Version: 0.0.3
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: bioimageio-core>=0.6.0
+Requires-Dist: numpy<2.0.0
+Requires-Dist: psutil
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pytorch-lightning>=2.2.0
+Requires-Dist: pyyaml
+Requires-Dist: scikit-image<=0.23.2
+Requires-Dist: tifffile
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision
+Requires-Dist: zarr<3.0.0
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: sybil; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: careamics-portfolio; extra == 'examples'
+Requires-Dist: jupyter; extra == 'examples'
+Requires-Dist: matplotlib; extra == 'examples'
+Provides-Extra: tensorboard
+Requires-Dist: protobuf==3.20.3; 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)
+
+
+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!