careamics 0.0.4.2__py3-none-any.whl → 0.0.6__py3-none-any.whl

careamics/config/n2n_configuration.py

@@ -0,0 +1,101 @@
+"""N2N configuration."""
+
+from bioimageio.spec.generic.v0_3 import CiteEntry
+
+from careamics.config.algorithms import N2NAlgorithm
+from careamics.config.configuration import Configuration
+from careamics.config.data import DataConfig
+
+N2N = "Noise2Noise"
+
+N2N_DESCRIPTION = (
+    "Noise2Noise is a deep-learning-based algorithm that uses a U-Net "
+    "architecture to restore images. Noise2Noise is a self-supervised "
+    "algorithm that requires only noisy images to train the network. "
+    "The algorithm learns to predict the clean image from the noisy "
+    "image. Noise2Noise is particularly useful when clean images are "
+    "not available for training."
+)
+
+N2N_REF = CiteEntry(
+    text="Lehtinen, J., Munkberg, J., Hasselgren, J., Laine, S., Karras, T., "
+    'Aittala, M. and Aila, T., 2018. "Noise2Noise: Learning image restoration '
+    'without clean data". arXiv preprint arXiv:1803.04189.',
+    doi="10.48550/arXiv.1803.04189",
+)
+
+
+class N2NConfiguration(Configuration):
+    """Noise2Noise configuration."""
+
+    algorithm_config: N2NAlgorithm
+    """Algorithm configuration."""
+
+    data_config: DataConfig
+    """Data configuration."""
+
+    def get_algorithm_friendly_name(self) -> str:
+        """
+        Get the algorithm friendly name.
+
+        Returns
+        -------
+        str
+            Friendly name of the algorithm.
+        """
+        return N2N
+
+    def get_algorithm_keywords(self) -> list[str]:
+        """
+        Get algorithm keywords.
+
+        Returns
+        -------
+        list[str]
+            List of keywords.
+        """
+        return [
+            "restoration",
+            "UNet",
+            "3D" if "Z" in self.data_config.axes else "2D",
+            "CAREamics",
+            "pytorch",
+            N2N,
+        ]
+
+    def get_algorithm_references(self) -> str:
+        """
+        Get the algorithm references.
+
+        This is used to generate the README of the BioImage Model Zoo export.
+
+        Returns
+        -------
+        str
+            Algorithm references.
+        """
+        return N2N_REF.text + " doi: " + N2N_REF.doi
+
+    def get_algorithm_citations(self) -> list[CiteEntry]:
+        """
+        Return a list of citation entries of the current algorithm.
+
+        This is used to generate the model description for the BioImage Model Zoo.
+
+        Returns
+        -------
+        List[CiteEntry]
+            List of citation entries.
+        """
+        return [N2N_REF]
+
+    def get_algorithm_description(self) -> str:
+        """
+        Get the algorithm description.
+
+        Returns
+        -------
+        str
+            Algorithm description.
+        """
+        return N2N_DESCRIPTION

careamics/config/n2v_configuration.py

@@ -0,0 +1,266 @@
+"""N2V configuration."""
+
+from bioimageio.spec.generic.v0_3 import CiteEntry
+from pydantic import model_validator
+from typing_extensions import Self
+
+from careamics.config.algorithms import N2VAlgorithm
+from careamics.config.configuration import Configuration
+from careamics.config.data.n2v_data_model import N2VDataConfig
+from careamics.config.support import SupportedPixelManipulation
+
+N2V = "Noise2Void"
+N2V2 = "N2V2"
+STRUCT_N2V = "StructN2V"
+STRUCT_N2V2 = "StructN2V2"
+
+N2V_REF = CiteEntry(
+    text='Krull, A., Buchholz, T.O. and Jug, F., 2019. "Noise2Void - Learning '
+    'denoising from single noisy images". In Proceedings of the IEEE/CVF '
+    "conference on computer vision and pattern recognition (pp. 2129-2137).",
+    doi="10.1109/cvpr.2019.00223",
+)
+
+N2V2_REF = CiteEntry(
+    text="Höck, E., Buchholz, T.O., Brachmann, A., Jug, F. and Freytag, A., "
+    '2022. "N2V2 - Fixing Noise2Void checkerboard artifacts with modified '
+    'sampling strategies and a tweaked network architecture". In European '
+    "Conference on Computer Vision (pp. 503-518).",
+    doi="10.1007/978-3-031-25069-9_33",
+)
+
+STRUCTN2V_REF = CiteEntry(
+    text="Broaddus, C., Krull, A., Weigert, M., Schmidt, U. and Myers, G., 2020."
+    '"Removing structured noise with self-supervised blind-spot '
+    'networks". In 2020 IEEE 17th International Symposium on Biomedical '
+    "Imaging (ISBI) (pp. 159-163).",
+    doi="10.1109/isbi45749.2020.9098336",
+)
+
+N2V_DESCRIPTION = (
+    "Noise2Void is a UNet-based self-supervised algorithm that "
+    "uses blind-spot training to denoise images. In short, in every "
+    "patches during training, random pixels are selected and their "
+    "value replaced by a neighboring pixel value. The network is then "
+    "trained to predict the original pixel value. The algorithm "
+    "relies on the continuity of the signal (neighboring pixels have "
+    "similar values) and the pixel-wise independence of the noise "
+    "(the noise in a pixel is not correlated with the noise in "
+    "neighboring pixels)."
+)
+
+N2V2_DESCRIPTION = (
+    "N2V2 is a variant of Noise2Void. "
+    + N2V_DESCRIPTION
+    + "\nN2V2 introduces blur-pool layers and removed skip "
+    "connections in the UNet architecture to remove checkboard "
+    "artefacts, a common artefacts ocurring in Noise2Void."
+)
+
+STR_N2V_DESCRIPTION = (
+    "StructN2V is a variant of Noise2Void. "
+    + N2V_DESCRIPTION
+    + "\nStructN2V uses a linear mask (horizontal or vertical) to replace "
+    "the pixel values of neighbors of the masked pixels by a random "
+    "value. Such masking allows removing 1D structured noise from the "
+    "the images, the main failure case of the original N2V."
+)
+
+STR_N2V2_DESCRIPTION = (
+    "StructN2V2 is a a variant of Noise2Void that uses both "
+    "structN2V and N2V2. "
+    + N2V_DESCRIPTION
+    + "\nStructN2V2 uses a linear mask (horizontal or vertical) to replace "
+    "the pixel values of neighbors of the masked pixels by a random "
+    "value. Such masking allows removing 1D structured noise from the "
+    "the images, the main failure case of the original N2V."
+    "\nN2V2 introduces blur-pool layers and removed skip connections in "
+    "the UNet architecture to remove checkboard artefacts, a common "
+    "artefacts ocurring in Noise2Void."
+)
+
+
+class N2VConfiguration(Configuration):
+    """N2V configuration."""
+
+    algorithm_config: N2VAlgorithm
+
+    data_config: N2VDataConfig
+
+    @model_validator(mode="after")
+    def validate_n2v2(self) -> Self:
+        """Validate that the N2V2 strategy and models are set correctly.
+
+        Returns
+        -------
+        Self
+            The validateed configuration.
+
+
+        Raises
+        ------
+        ValueError
+            If N2V2 is used with the wrong pixel manipulation strategy.
+        """
+        if self.algorithm_config.model.n2v2:
+            if (
+                self.data_config.get_masking_strategy()
+                != SupportedPixelManipulation.MEDIAN.value
+            ):
+                raise ValueError(
+                    f"N2V2 can only be used with the "
+                    f"{SupportedPixelManipulation.MEDIAN} pixel manipulation strategy"
+                    f". Change the N2VManipulate transform strategy."
+                )
+        else:
+            if (
+                self.data_config.get_masking_strategy()
+                != SupportedPixelManipulation.UNIFORM.value
+            ):
+                raise ValueError(
+                    f"N2V can only be used with the "
+                    f"{SupportedPixelManipulation.UNIFORM} pixel manipulation strategy"
+                    f". Change the N2VManipulate transform strategy."
+                )
+        return self
+
+    def set_n2v2(self, use_n2v2: bool) -> None:
+        """
+        Set the configuration to use N2V2 or the vanilla Noise2Void.
+
+        Parameters
+        ----------
+        use_n2v2 : bool
+            Whether to use N2V2.
+        """
+        self.data_config.set_n2v2(use_n2v2)
+        self.algorithm_config.model.n2v2 = use_n2v2
+
+    def get_algorithm_friendly_name(self) -> str:
+        """
+        Get the friendly name of the algorithm.
+
+        Returns
+        -------
+        str
+            Friendly name.
+        """
+        use_n2v2 = self.algorithm_config.model.n2v2
+        use_structN2V = self.data_config.is_using_struct_n2v()
+
+        if use_n2v2 and use_structN2V:
+            return STRUCT_N2V2
+        elif use_n2v2:
+            return N2V2
+        elif use_structN2V:
+            return STRUCT_N2V
+        else:
+            return N2V
+
+    def get_algorithm_keywords(self) -> list[str]:
+        """
+        Get algorithm keywords.
+
+        Returns
+        -------
+        list[str]
+            List of keywords.
+        """
+        use_n2v2 = self.algorithm_config.model.n2v2
+        use_structN2V = self.data_config.is_using_struct_n2v()
+
+        keywords = [
+            "denoising",
+            "restoration",
+            "UNet",
+            "3D" if "Z" in self.data_config.axes else "2D",
+            "CAREamics",
+            "pytorch",
+            N2V,
+        ]
+
+        if use_n2v2:
+            keywords.append(N2V2)
+        if use_structN2V:
+            keywords.append(STRUCT_N2V)
+
+        return keywords
+
+    def get_algorithm_references(self) -> str:
+        """
+        Get the algorithm references.
+
+        This is used to generate the README of the BioImage Model Zoo export.
+
+        Returns
+        -------
+        str
+            Algorithm references.
+        """
+        use_n2v2 = self.algorithm_config.model.n2v2
+        use_structN2V = self.data_config.is_using_struct_n2v()
+
+        references = [
+            N2V_REF.text + " doi: " + N2V_REF.doi,
+            N2V2_REF.text + " doi: " + N2V2_REF.doi,
+            STRUCTN2V_REF.text + " doi: " + STRUCTN2V_REF.doi,
+        ]
+
+        # return the (struct)N2V(2) references
+        if use_n2v2 and use_structN2V:
+            return "\n".join(references)
+        elif use_n2v2:
+            references.pop(-1)
+            return "\n".join(references)
+        elif use_structN2V:
+            references.pop(-2)
+            return "\n".join(references)
+        else:
+            return references[0]
+
+    def get_algorithm_citations(self) -> list[CiteEntry]:
+        """
+        Return a list of citation entries of the current algorithm.
+
+        This is used to generate the model description for the BioImage Model Zoo.
+
+        Returns
+        -------
+        List[CiteEntry]
+            List of citation entries.
+        """
+        use_n2v2 = self.algorithm_config.model.n2v2
+        use_structN2V = self.data_config.is_using_struct_n2v()
+
+        references = [N2V_REF]
+
+        if use_n2v2:
+            references.append(N2V2_REF)
+
+        if use_structN2V:
+            references.append(STRUCTN2V_REF)
+
+        return references
+
+    def get_algorithm_description(self) -> str:
+        """
+        Return a description of the algorithm.
+
+        This method is used to generate the README of the BioImage Model Zoo export.
+
+        Returns
+        -------
+        str
+            Description of the algorithm.
+        """
+        use_n2v2 = self.algorithm_config.model.n2v2
+        use_structN2V = self.data_config.is_using_struct_n2v()
+
+        if use_n2v2 and use_structN2V:
+            return STR_N2V2_DESCRIPTION
+        elif use_n2v2:
+            return N2V2_DESCRIPTION
+        elif use_structN2V:
+            return STR_N2V_DESCRIPTION
+        else:
+            return N2V_DESCRIPTION

careamics/config/nm_model.py

@@ -1,7 +1,7 @@
 """Noise models config."""
 
 from pathlib import Path
-from typing import Literal, Optional, Union
+from typing import Annotated, Literal, Optional, Union
 
 import numpy as np
 import torch
@@ -11,9 +11,7 @@ from pydantic import (
     Field,
     PlainSerializer,
     PlainValidator,
-    model_validator,
 )
-from typing_extensions import Annotated, Self
 
 from careamics.utils.serializers import _array_to_json, _to_numpy
 
@@ -90,28 +88,29 @@ class GaussianMixtureNMConfig(BaseModel):
     tol: float = Field(default=1e-10)
     """Tolerance used in the computation of the noise model likelihood."""
 
-    @model_validator(mode="after")
-    def validate_path_to_pretrained_vs_training_data(self: Self) -> Self:
-        """Validate paths provided in the config.
-
-        Returns
-        -------
-        Self
-            Returns itself.
-        """
-        if self.path and (self.signal is not None or self.observation is not None):
-            raise ValueError(
-                "Either only 'path' to pre-trained noise model should be"
-                "provided or only signal and observation in form of paths"
-                "or numpy arrays."
-            )
-        if not self.path and (self.signal is None or self.observation is None):
-            raise ValueError(
-                "Either only 'path' to pre-trained noise model should be"
-                "provided or only signal and observation in form of paths"
-                "or numpy arrays."
-            )
-        return self
+    # @model_validator(mode="after")
+    # def validate_path_to_pretrained_vs_training_data(self: Self) -> Self:
+    #     """Validate paths provided in the config.
+
+    #     Returns
+    #     -------
+    #     Self
+    #         Returns itself.
+    #     """
+    #     if self.path and (self.signal is not None or self.observation is not None):
+    #         raise ValueError(
+    #             "Either only 'path' to pre-trained noise model should be"
+    #             "provided or only signal and observation in form of paths"
+    #             "or numpy arrays."
+    #         )
+    #     if not self.path and (self.signal is None or self.observation is None):
+    #         raise ValueError(
+    #             "Either only 'path' to pre-trained noise model should be"
+    #             "provided or only signal and observation in form of paths"
+    #             "or numpy arrays."
+    #         )
+    #     return self
+    # TODO revisit validation
 
 
 # The noise model is given by a set of GMMs, one for each target

careamics/config/support/__init__.py

@@ -5,17 +5,17 @@ corresponding configuration options in the Pydantic models.
 """
 
 __all__ = [
-    "SupportedArchitecture",
     "SupportedActivation",
-    "SupportedOptimizer",
-    "SupportedScheduler",
-    "SupportedLoss",
     "SupportedAlgorithm",
-    "SupportedPixelManipulation",
-    "SupportedTransform",
+    "SupportedArchitecture",
     "SupportedData",
-    "SupportedStructAxis",
     "SupportedLogger",
+    "SupportedLoss",
+    "SupportedOptimizer",
+    "SupportedPixelManipulation",
+    "SupportedScheduler",
+    "SupportedStructAxis",
+    "SupportedTransform",
 ]
 
 

careamics/config/support/supported_algorithms.py

@@ -25,9 +25,6 @@ class SupportedAlgorithm(str, BaseEnum):
     DENOISPLIT = "denoisplit"
     """An image splitting and denoising approach based on ladder VAE architectures."""
 
-    CUSTOM = "custom"
-    """Custom algorithm, used for cases where a custom architecture is provided."""
-
     # PN2V = "pn2v"
     # HDN = "hdn"
     # SEG = "segmentation"

careamics/config/support/supported_architectures.py

@@ -11,7 +11,3 @@ class SupportedArchitecture(str, BaseEnum):
 
     LVAE = "LVAE"
     """Ladder Variational Autoencoder used for muSplit and denoiSplit."""
-
-    CUSTOM = "custom"
-    """Keyword used for custom architectures provided by users and only compatible
-    with `FCNAlgorithmConfig` configuration."""

careamics/config/transformations/__init__.py

@@ -1,18 +1,24 @@
 """CAREamics transformation Pydantic models."""
 
 __all__ = [
+    "N2V_TRANSFORMS_UNION",
+    "NORM_AND_SPATIAL_UNION",
+    "SPATIAL_TRANSFORMS_UNION",
     "N2VManipulateModel",
-    "XYFlipModel",
     "NormalizeModel",
-    "XYRandomRotate90Model",
     "TransformModel",
-    "TRANSFORMS_UNION",
+    "XYFlipModel",
+    "XYRandomRotate90Model",
 ]
 
 
 from .n2v_manipulate_model import N2VManipulateModel
 from .normalize_model import NormalizeModel
 from .transform_model import TransformModel
-from .transform_union import TRANSFORMS_UNION
+from .transform_unions import (
+    N2V_TRANSFORMS_UNION,
+    NORM_AND_SPATIAL_UNION,
+    SPATIAL_TRANSFORMS_UNION,
+)
 from .xy_flip_model import XYFlipModel
 from .xy_random_rotate90_model import XYRandomRotate90Model

careamics/config/transformations/transform_model.py

@@ -1,6 +1,6 @@
 """Parent model for the transforms."""
 
-from typing import Any, Dict
+from typing import Any
 
 from pydantic import BaseModel, ConfigDict
 
@@ -23,7 +23,7 @@ class TransformModel(BaseModel):
 
     name: str
 
-    def model_dump(self, **kwargs) -> Dict[str, Any]:
+    def model_dump(self, **kwargs) -> dict[str, Any]:
         """
         Return the model as a dictionary.
 
@@ -34,7 +34,7 @@ class TransformModel(BaseModel):
 
         Returns
         -------
-        Dict[str, Any]
+        {str: Any}
             Dictionary representation of the model.
         """
         model_dict = super().model_dump(**kwargs)

careamics/config/transformations/transform_unions.py

@@ -0,0 +1,42 @@
+"""Type used to represent all transformations users can create."""
+
+from typing import Annotated, Union
+
+from pydantic import Discriminator
+
+from .n2v_manipulate_model import N2VManipulateModel
+from .normalize_model import NormalizeModel
+from .xy_flip_model import XYFlipModel
+from .xy_random_rotate90_model import XYRandomRotate90Model
+
+NORM_AND_SPATIAL_UNION = Annotated[
+    Union[
+        NormalizeModel,
+        XYFlipModel,
+        XYRandomRotate90Model,
+        N2VManipulateModel,
+    ],
+    Discriminator("name"),  # used to tell the different transform models apart
+]
+"""All transforms including normalization."""
+
+
+SPATIAL_TRANSFORMS_UNION = Annotated[
+    Union[
+        XYFlipModel,
+        XYRandomRotate90Model,
+    ],
+    Discriminator("name"),  # used to tell the different transform models apart
+]
+"""Available spatial transforms in CAREamics."""
+
+
+N2V_TRANSFORMS_UNION = Annotated[
+    Union[
+        XYFlipModel,
+        XYRandomRotate90Model,
+        N2VManipulateModel,
+    ],
+    Discriminator("name"),  # used to tell the different transform models apart
+]
+"""Available N2V-compatible transforms in CAREamics."""

careamics/config/validators/validator_utils.py

@@ -4,7 +4,7 @@ Validator functions.
 These functions are used to validate dimensions and axes of inputs.
 """
 
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 _AXES = "STCZYX"
 
@@ -79,14 +79,14 @@ def value_ge_than_8_power_of_2(
 
 
 def patch_size_ge_than_8_power_of_2(
-    patch_list: Optional[Union[List[int], Union[Tuple[int, ...]]]],
+    patch_list: Optional[Union[list[int], Union[tuple[int, ...]]]],
 ) -> None:
     """
     Validate that each entry is greater or equal than 8 and a power of 2.
 
     Parameters
     ----------
-    patch_list : Optional[Union[List[int]]]
+    patch_list : list or typle of int, or None
         Patch size.
 
     Raises

careamics/dataset/__init__.py

@@ -4,9 +4,9 @@ __all__ = [
     "InMemoryDataset",
     "InMemoryPredDataset",
     "InMemoryTiledPredDataset",
-    "PathIterableDataset",
-    "IterableTiledPredDataset",
     "IterablePredDataset",
+    "IterableTiledPredDataset",
+    "PathIterableDataset",
 ]
 
 from .in_memory_dataset import InMemoryDataset

careamics/dataset/dataset_utils/__init__.py

@@ -1,13 +1,13 @@
 """Files and arrays utils used in the datasets."""
 
 __all__ = [
-    "reshape_array",
+    "WelfordStatistics",
     "compute_normalization_stats",
     "get_files_size",
+    "iterate_over_files",
     "list_files",
+    "reshape_array",
     "validate_source_target_files",
-    "iterate_over_files",
-    "WelfordStatistics",
 ]
 
 

careamics/dataset/dataset_utils/dataset_utils.py

@@ -1,7 +1,5 @@
 """Dataset utilities."""
 
-from typing import List, Tuple
-
 import numpy as np
 
 from careamics.utils.logging import get_logger
@@ -10,14 +8,14 @@ logger = get_logger(__name__)
 
 
 def _get_shape_order(
-    shape_in: Tuple[int, ...], axes_in: str, ref_axes: str = "STCZYX"
-) -> Tuple[Tuple[int, ...], str, List[int]]:
+    shape_in: tuple[int, ...], axes_in: str, ref_axes: str = "STCZYX"
+) -> tuple[tuple[int, ...], str, list[int]]:
     """
     Compute a new shape for the array based on the reference axes.
 
     Parameters
     ----------
-    shape_in : Tuple[int, ...]
+    shape_in : tuple[int, ...]
         Input shape.
     axes_in : str
         Input axes.
@@ -26,7 +24,7 @@ def _get_shape_order(
 
     Returns
     -------
-    Tuple[Tuple[int, ...], str, List[int]]
+    tuple[tuple[int, ...], str, list[int]]
         New shape, new axes, indices of axes in the new axes order.
     """
     indices = [axes_in.find(k) for k in ref_axes]