careamics 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

careamics/utils/metrics.py

@@ -4,88 +4,98 @@ Metrics submodule.
 This module contains various metrics and a metrics tracking class.
 """
 
-from typing import Union
+from typing import Callable, Optional, Union
 
 import numpy as np
 import torch
-from skimage.metrics import peak_signal_noise_ratio
+from skimage.metrics import peak_signal_noise_ratio, structural_similarity
+from torchmetrics.image import MultiScaleStructuralSimilarityIndexMeasure
 
+# TODO: does this add additional dependency?
 
-def psnr(gt: np.ndarray, pred: np.ndarray, range: float = 255.0) -> float:
+
+def psnr(gt: np.ndarray, pred: np.ndarray, data_range: float) -> 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.
 
+    NOTE: to avoid unwanted behaviors (e.g., data_range inferred from array dtype),
+    the data_range parameter is mandatory.
+
     Parameters
     ----------
-    gt : NumPy array
-        Ground truth image.
-    pred : NumPy array
-        Predicted image.
-    range : float, optional
-        The images pixel range, by default 255.0.
+    gt : np.ndarray
+        Ground truth array.
+    pred : np.ndarray
+        Predicted array.
+    data_range : float
+        The images pixel range.
 
     Returns
     -------
     float
         PSNR value.
     """
-    return peak_signal_noise_ratio(gt, pred, data_range=range)
+    return peak_signal_noise_ratio(gt, pred, data_range=data_range)
 
 
-def _zero_mean(x: np.ndarray) -> np.ndarray:
+def _zero_mean(x: Union[np.ndarray, torch.Tensor]) -> Union[np.ndarray, torch.Tensor]:
     """
     Zero the mean of an array.
 
     Parameters
     ----------
-    x : NumPy array
+    x : numpy.ndarray or torch.Tensor
         Input array.
 
     Returns
     -------
-    NumPy array
+    numpy.ndarray or torch.Tensor
         Zero-mean array.
     """
-    return x - np.mean(x)
+    return x - x.mean()
 
 
-def _fix_range(gt: np.ndarray, x: np.ndarray) -> np.ndarray:
+def _fix_range(
+    gt: Union[np.ndarray, torch.Tensor], x: Union[np.ndarray, torch.Tensor]
+) -> Union[np.ndarray, torch.Tensor]:
     """
     Adjust the range of an array based on a reference ground-truth array.
 
     Parameters
     ----------
-    gt : np.ndarray
-        Ground truth image.
-    x : np.ndarray
+    gt : Union[np.ndarray, torch.Tensor]
+        Ground truth array.
+    x : Union[np.ndarray, torch.Tensor]
         Input array.
 
     Returns
     -------
-    np.ndarray
+    Union[np.ndarray, torch.Tensor]
         Range-adjusted array.
     """
-    a = np.sum(gt * x) / (np.sum(x * x))
+    a = (gt * x).sum() / (x * x).sum()
     return x * a
 
 
-def _fix(gt: np.ndarray, x: np.ndarray) -> np.ndarray:
+def _fix(
+    gt: Union[np.ndarray, torch.Tensor], x: Union[np.ndarray, torch.Tensor]
+) -> Union[np.ndarray, torch.Tensor]:
     """
     Zero mean a groud truth array and adjust the range of the array.
 
     Parameters
     ----------
-    gt : np.ndarray
+    gt : Union[np.ndarray, torch.Tensor]
         Ground truth image.
-    x : np.ndarray
+    x : Union[np.ndarray, torch.Tensor]
         Input array.
 
     Returns
     -------
-    np.ndarray
+    Union[np.ndarray, torch.Tensor]
         Zero-mean and range-adjusted array.
     """
     gt_ = _zero_mean(gt)
@@ -113,3 +123,246 @@ def scale_invariant_psnr(
     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)
+
+
+def _range_invariant_multiscale_ssim(
+    gt_: Union[np.ndarray, torch.Tensor], pred_: Union[np.ndarray, torch.Tensor]
+) -> float:
+    """Compute range invariant multiscale SSIM for a single channel.
+
+    The advantage of this metric in comparison to commonly used SSIM is that
+    it is invariant to scalar multiplications in the prediction.
+    # TODO: Add reference to the paper.
+
+    NOTE: images fed to this function should have channels dimension as the last one.
+
+    Parameters
+    ----------
+    gt_ : Union[np.ndarray, torch.Tensor]
+        Ground truth image with shape (N, H, W).
+    pred_ : Union[np.ndarray, torch.Tensor]
+        Predicted image with shape (N, H, W).
+
+    Returns
+    -------
+    float
+        Range invariant multiscale SSIM value.
+    """
+    shape = gt_.shape
+    gt_ = torch.Tensor(gt_.reshape((shape[0], -1)))
+    pred_ = torch.Tensor(pred_.reshape((shape[0], -1)))
+    gt_ = _zero_mean(gt_)
+    pred_ = _zero_mean(pred_)
+    pred_ = _fix(gt_, pred_)
+    pred_ = pred_.reshape(shape)
+    gt_ = gt_.reshape(shape)
+
+    ms_ssim = MultiScaleStructuralSimilarityIndexMeasure(
+        data_range=gt_.max() - gt_.min()
+    )
+    return ms_ssim(torch.Tensor(pred_[:, None]), torch.Tensor(gt_[:, None])).item()
+
+
+def multiscale_ssim(
+    gt_: Union[np.ndarray, torch.Tensor],
+    pred_: Union[np.ndarray, torch.Tensor],
+    range_invariant: bool = True,
+) -> list[Union[float, None]]:
+    """Compute channel-wise multiscale SSIM for each channel.
+
+    It allows to use either standard multiscale SSIM or its range-invariant version.
+
+    NOTE: images fed to this function should have channels dimension as the last one.
+    # TODO: do we want to allow this behavior? or we want the usual (N, C, H, W)?
+
+    Parameters
+    ----------
+    gt_ : Union[np.ndarray, torch.Tensor]
+        Ground truth image with shape (N, H, W, C).
+    pred_ : Union[np.ndarray, torch.Tensor]
+        Predicted image with shape (N, H, W, C).
+    range_invariant : bool
+        Whether to use standard or range invariant multiscale SSIM.
+
+    Returns
+    -------
+    list[float]
+        List of SSIM values for each channel.
+    """
+    ms_ssim_values = {}
+    for ch_idx in range(gt_.shape[-1]):
+        tar_tmp = gt_[..., ch_idx]
+        pred_tmp = pred_[..., ch_idx]
+        if range_invariant:
+            ms_ssim_values[ch_idx] = _range_invariant_multiscale_ssim(
+                gt_=tar_tmp, pred_=pred_tmp
+            )
+        else:
+            ms_ssim = MultiScaleStructuralSimilarityIndexMeasure(
+                data_range=tar_tmp.max() - tar_tmp.min()
+            )
+            ms_ssim_values[ch_idx] = ms_ssim(
+                torch.Tensor(pred_tmp[:, None]), torch.Tensor(tar_tmp[:, None])
+            ).item()
+
+    return [ms_ssim_values[i] for i in range(gt_.shape[-1])]  # type: ignore
+
+
+def _avg_psnr(target: np.ndarray, prediction: np.ndarray, psnr_fn: Callable) -> float:
+    """Compute the average PSNR over a batch of images.
+
+    Parameters
+    ----------
+    target : np.ndarray
+        Array of ground truth images, shape is (N, C, H, W).
+    prediction : np.ndarray
+        Array of predicted images, shape is (N, C, H, W).
+    psnr_fn : Callable
+        PSNR function to use.
+
+    Returns
+    -------
+    float
+        Average PSNR value over the batch.
+    """
+    return np.mean(
+        [
+            psnr_fn(target[i : i + 1], prediction[i : i + 1]).item()
+            for i in range(len(prediction))
+        ]
+    )
+
+
+def avg_range_inv_psnr(target: np.ndarray, prediction: np.ndarray) -> float:
+    """Compute the average range-invariant PSNR over a batch of images.
+
+    Parameters
+    ----------
+    target : np.ndarray
+        Array of ground truth images, shape is (N, C, H, W).
+    prediction : np.ndarray
+        Array of predicted images, shape is (N, C, H, W).
+
+    Returns
+    -------
+    float
+        Average range-invariant PSNR value over the batch.
+    """
+    return _avg_psnr(target, prediction, scale_invariant_psnr)
+
+
+def avg_psnr(target: np.ndarray, prediction: np.ndarray) -> float:
+    """Compute the average PSNR over a batch of images.
+
+    Parameters
+    ----------
+    target : np.ndarray
+        Array of ground truth images, shape is (N, C, H, W).
+    prediction : np.ndarray
+        Array of predicted images, shape is (N, C, H, W).
+
+    Returns
+    -------
+    float
+        Average PSNR value over the batch.
+    """
+    return _avg_psnr(target, prediction, psnr)
+
+
+def avg_ssim(
+    target: Union[np.ndarray, torch.Tensor], prediction: Union[np.ndarray, torch.Tensor]
+) -> tuple[float, float]:
+    """Compute the average Structural Similarity (SSIM) over a batch of images.
+
+    Parameters
+    ----------
+    target : np.ndarray
+        Array of ground truth images, shape is (N, C, H, W).
+    prediction : np.ndarray
+        Array of predicted images, shape is (N, C, H, W).
+
+    Returns
+    -------
+    tuple[float, float]
+        Mean and standard deviation of SSIM values over the batch.
+    """
+    ssim = [
+        structural_similarity(
+            target[i], prediction[i], data_range=(target[i].max() - target[i].min())
+        )
+        for i in range(len(target))
+    ]
+    return np.mean(ssim), np.std(ssim)

careamics/utils/serializers.py

@@ -0,0 +1,60 @@
+"""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.
+    """
+    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-0.0.2.dist-info → careamics-0.0.4.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.3
 Name: careamics
-Version: 0.0.2
+Version: 0.0.4
 Summary: Toolbox for running N2V and friends.
 Project-URL: homepage, https://careamics.github.io/
 Project-URL: repository, https://github.com/CAREamics/careamics
-Author-email: Melisande Croft <melisande.croft@fht.org>, Joran Deschamps <joran.deschamps@fht.org>, Igor Zubarev <igor.zubarev@fht.org>
+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
@@ -16,16 +16,17 @@ 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: bioimageio-core>=0.6.9
 Requires-Dist: numpy<2.0.0
 Requires-Dist: psutil
-Requires-Dist: pydantic>=2.5
+Requires-Dist: pydantic<2.9,>=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: typer==0.12.3
 Requires-Dist: zarr<3.0.0
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == 'dev'