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

careamics/config/transformations/__init__.py

@@ -0,0 +1,15 @@
+"""CAREamics transformation Pydantic models."""
+
+__all__ = [
+    "N2VManipulateModel",
+    "XYFlipModel",
+    "NormalizeModel",
+    "XYRandomRotate90Model",
+    "XorYFlipModel",
+]
+
+
+from .n2v_manipulate_model import N2VManipulateModel
+from .normalize_model import NormalizeModel
+from .xy_flip_model import XYFlipModel
+from .xy_random_rotate90_model import XYRandomRotate90Model

careamics/config/transformations/n2v_manipulate_model.py

@@ -0,0 +1,64 @@
+"""Pydantic model for the N2VManipulate transform."""
+
+from typing import Literal
+
+from pydantic import ConfigDict, Field, field_validator
+
+from .transform_model import TransformModel
+
+
+class N2VManipulateModel(TransformModel):
+    """
+    Pydantic model used to represent N2V manipulation.
+
+    Attributes
+    ----------
+    name : Literal["N2VManipulate"]
+        Name of the transformation.
+    roi_size : int
+        Size of the masking region, by default 11.
+    masked_pixel_percentage : float
+        Percentage of masked pixels, by default 0.2.
+    strategy : Literal["uniform", "median"]
+        Strategy pixel value replacement, by default "uniform".
+    struct_mask_axis : Literal["horizontal", "vertical", "none"]
+        Axis of the structN2V mask, by default "none".
+    struct_mask_span : int
+        Span of the structN2V mask, by default 5.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    name: Literal["N2VManipulate"] = "N2VManipulate"
+    roi_size: int = Field(default=11, ge=3, le=21)
+    masked_pixel_percentage: float = Field(default=0.2, ge=0.05, le=10.0)
+    strategy: Literal["uniform", "median"] = Field(default="uniform")
+    struct_mask_axis: Literal["horizontal", "vertical", "none"] = Field(default="none")
+    struct_mask_span: int = Field(default=5, ge=3, le=15)
+
+    @field_validator("roi_size", "struct_mask_span")
+    @classmethod
+    def odd_value(cls, v: int) -> int:
+        """
+        Validate that the value is odd.
+
+        Parameters
+        ----------
+        v : int
+            Value to validate.
+
+        Returns
+        -------
+        int
+            The validated value.
+
+        Raises
+        ------
+        ValueError
+            If the value is even.
+        """
+        if v % 2 == 0:
+            raise ValueError("Size must be an odd number.")
+        return v

careamics/config/transformations/normalize_model.py

@@ -0,0 +1,60 @@
+"""Pydantic model for the Normalize transform."""
+
+from typing import Literal, Optional
+
+from pydantic import ConfigDict, Field, model_validator
+from typing_extensions import Self
+
+from .transform_model import TransformModel
+
+
+class NormalizeModel(TransformModel):
+    """
+    Pydantic model used to represent Normalize transformation.
+
+    The Normalize transform is a zero mean and unit variance transformation.
+
+    Attributes
+    ----------
+    name : Literal["Normalize"]
+        Name of the transformation.
+    mean : float
+        Mean value for normalization.
+    std : float
+        Standard deviation value for normalization.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    name: Literal["Normalize"] = "Normalize"
+    image_means: list = Field(..., min_length=0, max_length=32)
+    image_stds: list = Field(..., min_length=0, max_length=32)
+    target_means: Optional[list] = Field(default=None, min_length=0, max_length=32)
+    target_stds: Optional[list] = Field(default=None, min_length=0, max_length=32)
+
+    @model_validator(mode="after")
+    def validate_means_stds(self: Self) -> Self:
+        """Validate that the means and stds have the same length.
+
+        Returns
+        -------
+        Self
+            The instance of the model.
+        """
+        if len(self.image_means) != len(self.image_stds):
+            raise ValueError("The number of image means and stds must be the same.")
+
+        if (self.target_means is None) != (self.target_stds is None):
+            raise ValueError(
+                "Both target means and stds must be provided together, or bot None."
+            )
+
+        if self.target_means is not None and self.target_stds is not None:
+            if len(self.target_means) != len(self.target_stds):
+                raise ValueError(
+                    "The number of target means and stds must be the same."
+                )
+
+        return self

careamics/config/transformations/transform_model.py

@@ -0,0 +1,45 @@
+"""Parent model for the transforms."""
+
+from typing import Any, Dict
+
+from pydantic import BaseModel, ConfigDict
+
+
+class TransformModel(BaseModel):
+    """
+    Pydantic model used to represent a transformation.
+
+    The `model_dump` method is overwritten to exclude the name field.
+
+    Attributes
+    ----------
+    name : str
+        Name of the transformation.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",  # throw errors if the parameters are not properly passed
+    )
+
+    name: str
+
+    def model_dump(self, **kwargs) -> Dict[str, Any]:
+        """
+        Return the model as a dictionary.
+
+        Parameters
+        ----------
+        **kwargs
+            Pydantic BaseMode model_dump method keyword arguments.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Dictionary representation of the model.
+        """
+        model_dict = super().model_dump(**kwargs)
+
+        # remove the name field
+        model_dict.pop("name")
+
+        return model_dict

careamics/config/transformations/xy_flip_model.py

@@ -0,0 +1,43 @@
+"""Pydantic model for the XYFlip transform."""
+
+from typing import Literal, Optional
+
+from pydantic import ConfigDict, Field
+
+from .transform_model import TransformModel
+
+
+class XYFlipModel(TransformModel):
+    """
+    Pydantic model used to represent XYFlip transformation.
+
+    Attributes
+    ----------
+    name : Literal["XYFlip"]
+        Name of the transformation.
+    p : float
+        Probability of applying the transform, by default 0.5.
+    seed : Optional[int]
+        Seed for the random number generator,  by default None.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    name: Literal["XYFlip"] = "XYFlip"
+    flip_x: bool = Field(
+        True,
+        description="Whether to flip along the X axis.",
+    )
+    flip_y: bool = Field(
+        True,
+        description="Whether to flip along the Y axis.",
+    )
+    p: float = Field(
+        0.5,
+        description="Probability of applying the transform.",
+        ge=0,
+        le=1,
+    )
+    seed: Optional[int] = None

careamics/config/transformations/xy_random_rotate90_model.py

@@ -0,0 +1,35 @@
+"""Pydantic model for the XYRandomRotate90 transform."""
+
+from typing import Literal, Optional
+
+from pydantic import ConfigDict, Field
+
+from .transform_model import TransformModel
+
+
+class XYRandomRotate90Model(TransformModel):
+    """
+    Pydantic model used to represent the XY random 90 degree rotation transformation.
+
+    Attributes
+    ----------
+    name : Literal["XYRandomRotate90"]
+        Name of the transformation.
+    p : float
+        Probability of applying the transform, by default 0.5.
+    seed : Optional[int]
+        Seed for the random number generator, by default None.
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+    )
+
+    name: Literal["XYRandomRotate90"] = "XYRandomRotate90"
+    p: float = Field(
+        0.5,
+        description="Probability of applying the transform.",
+        ge=0,
+        le=1,
+    )
+    seed: Optional[int] = None

careamics/config/vae_algorithm_model.py

@@ -0,0 +1,171 @@
+"""Algorithm configuration."""
+
+from __future__ import annotations
+
+from pprint import pformat
+from typing import Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing_extensions import Self
+
+from careamics.config.support import SupportedAlgorithm, SupportedLoss
+
+from .architectures import CustomModel, LVAEModel
+from .likelihood_model import GaussianLikelihoodConfig, NMLikelihoodConfig
+from .nm_model import MultiChannelNMConfig
+from .optimizer_models import LrSchedulerModel, OptimizerModel
+
+
+class VAEAlgorithmConfig(BaseModel):
+    """Algorithm configuration.
+
+    This Pydantic model validates the parameters governing the components of the
+    training algorithm: which algorithm, loss function, model architecture, optimizer,
+    and learning rate scheduler to use.
+
+    Currently, we only support N2V, CARE, N2N and custom models. The `n2v` algorithm is
+    only compatible with `n2v` loss and `UNet` architecture. The `custom` algorithm
+    allows you to register your own architecture and select it using its name as
+    `name` in the custom pydantic model.
+
+    Attributes
+    ----------
+    algorithm : algorithm: Literal["musplit", "denoisplit", "custom"]
+        Algorithm to use.
+    loss : Literal["musplit", "denoisplit", "denoisplit_musplit"]
+        Loss function to use.
+    model : Union[LVAEModel, CustomModel]
+        Model architecture to use.
+    noise_model: Optional[MultiChannelNmModel]
+        Noise model to use.
+    noise_model_likelihood_model: Optional[NMLikelihoodModel]
+        Noise model likelihood model to use.
+    gaussian_likelihood_model: Optional[GaussianLikelihoodModel]
+        Gaussian likelihood model to use.
+    optimizer : OptimizerModel, optional
+        Optimizer to use.
+    lr_scheduler : LrSchedulerModel, optional
+        Learning rate scheduler to use.
+
+    Raises
+    ------
+    ValueError
+        Algorithm parameter type validation errors.
+    ValueError
+        If the algorithm, loss and model are not compatible.
+
+    Examples
+    --------
+    # TODO add once finalized
+    """
+
+    # Pydantic class configuration
+    model_config = ConfigDict(
+        protected_namespaces=(),  # allows to use model_* as a field name
+        validate_assignment=True,
+        extra="allow",
+    )
+
+    # Mandatory fields
+    # defined in SupportedAlgorithm
+    # TODO: Use supported Enum classes for typing?
+    #   - values can still be passed as strings and they will be cast to Enum
+    algorithm_type: Literal["vae"]
+    algorithm: Literal["musplit", "denoisplit", "custom"]
+    loss: Literal["musplit", "denoisplit", "denoisplit_musplit"]
+    model: Union[LVAEModel, CustomModel] = Field(discriminator="architecture")
+
+    # TODO: these are configs, change naming of attrs
+    noise_model: Optional[MultiChannelNMConfig] = None
+    noise_model_likelihood_model: Optional[NMLikelihoodConfig] = None
+    gaussian_likelihood_model: Optional[GaussianLikelihoodConfig] = None
+
+    # Optional fields
+    optimizer: OptimizerModel = OptimizerModel()
+    """Optimizer to use, defined in SupportedOptimizer."""
+
+    lr_scheduler: LrSchedulerModel = LrSchedulerModel()
+
+    @model_validator(mode="after")
+    def algorithm_cross_validation(self: Self) -> Self:
+        """Validate the algorithm model based on `algorithm`.
+
+        Returns
+        -------
+        Self
+            The validated model.
+        """
+        # musplit
+        if self.algorithm == SupportedAlgorithm.MUSPLIT:
+            if self.loss != SupportedLoss.MUSPLIT:
+                raise ValueError(
+                    f"Algorithm {self.algorithm} only supports loss `musplit`."
+                )
+
+        if self.algorithm == SupportedAlgorithm.DENOISPLIT:
+            if self.loss not in [
+                SupportedLoss.DENOISPLIT,
+                SupportedLoss.DENOISPLIT_MUSPLIT,
+            ]:
+                raise ValueError(
+                    f"Algorithm {self.algorithm} only supports loss `denoisplit` "
+                    "or `denoisplit_musplit."
+                )
+            if (
+                self.loss == SupportedLoss.DENOISPLIT
+                and self.model.predict_logvar is not None
+            ):
+                raise ValueError(
+                    "Algorithm `denoisplit` with loss `denoisplit` only supports "
+                    "`predict_logvar` as `None`."
+                )
+            if self.noise_model is None:
+                raise ValueError("Algorithm `denoisplit` requires a noise model.")
+        # TODO: what if algorithm is not musplit or denoisplit (HDN?)
+        return self
+
+    @model_validator(mode="after")
+    def output_channels_validation(self: Self) -> Self:
+        """Validate the consistency between number of out channels and noise models.
+
+        Returns
+        -------
+        Self
+            The validated model.
+        """
+        if self.noise_model is not None:
+            assert self.model.output_channels == len(self.noise_model.noise_models), (
+                f"Number of output channels ({self.model.output_channels}) must match "
+                f"the number of noise models ({len(self.noise_model.noise_models)})."
+            )
+        return self
+
+    @model_validator(mode="after")
+    def predict_logvar_validation(self: Self) -> Self:
+        """Validate the consistency of `predict_logvar` throughout the model.
+
+        Returns
+        -------
+        Self
+            The validated model.
+        """
+        if self.gaussian_likelihood_model is not None:
+            assert (
+                self.model.predict_logvar
+                == self.gaussian_likelihood_model.predict_logvar
+            ), (
+                f"Model `predict_logvar` ({self.model.predict_logvar}) must match "
+                "Gaussian likelihood model `predict_logvar` "
+                f"({self.gaussian_likelihood_model.predict_logvar}).",
+            )
+        return self
+
+    def __str__(self) -> str:
+        """Pretty string representing the configuration.
+
+        Returns
+        -------
+        str
+            Pretty string.
+        """
+        return pformat(self.model_dump())

careamics/config/validators/__init__.py

@@ -0,0 +1,5 @@
+"""Validator utilities."""
+
+__all__ = ["check_axes_validity", "patch_size_ge_than_8_power_of_2"]
+
+from .validator_utils import check_axes_validity, patch_size_ge_than_8_power_of_2

careamics/config/validators/validator_utils.py

@@ -0,0 +1,101 @@
+"""
+Validator functions.
+
+These functions are used to validate dimensions and axes of inputs.
+"""
+
+from typing import List, Optional, Tuple, Union
+
+_AXES = "STCZYX"
+
+
+def check_axes_validity(axes: str) -> None:
+    """
+    Sanity check on axes.
+
+    The constraints on the axes are the following:
+    - must be a combination of 'STCZYX'
+    - must not contain duplicates
+    - must contain at least 2 contiguous axes: X and Y
+    - must contain at most 4 axes
+    - cannot contain both S and T axes
+
+    Axes do not need to be in the order 'STCZYX', as this depends on the user data.
+
+    Parameters
+    ----------
+    axes : str
+        Axes to validate.
+    """
+    _axes = axes.upper()
+
+    # Minimum is 2 (XY) and maximum is 4 (TZYX)
+    if len(_axes) < 2 or len(_axes) > 6:
+        raise ValueError(
+            f"Invalid axes {axes}. Must contain at least 2 and at most 6 axes."
+        )
+
+    if "YX" not in _axes and "XY" not in _axes:
+        raise ValueError(
+            f"Invalid axes {axes}. Must contain at least X and Y axes consecutively."
+        )
+
+    # all characters must be in REF_AXES = 'STCZYX'
+    if not all(s in _AXES for s in _axes):
+        raise ValueError(f"Invalid axes {axes}. Must be a combination of {_AXES}.")
+
+    # check for repeating characters
+    for i, s in enumerate(_axes):
+        if i != _axes.rfind(s):
+            raise ValueError(
+                f"Invalid axes {axes}. Cannot contain duplicate axes"
+                f" (got multiple {axes[i]})."
+            )
+
+
+def value_ge_than_8_power_of_2(
+    value: int,
+) -> None:
+    """
+    Validate that the value is greater or equal than 8 and a power of 2.
+
+    Parameters
+    ----------
+    value : int
+        Value to validate.
+
+    Raises
+    ------
+    ValueError
+        If the value is smaller than 8.
+    ValueError
+        If the value is not a power of 2.
+    """
+    if value < 8:
+        raise ValueError(f"Value must be greater than 8 (got {value}).")
+
+    if (value & (value - 1)) != 0:
+        raise ValueError(f"Value must be a power of 2 (got {value}).")
+
+
+def patch_size_ge_than_8_power_of_2(
+    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 size.
+
+    Raises
+    ------
+    ValueError
+        If the patch size if smaller than 8.
+    ValueError
+        If the patch size is not a power of 2.
+    """
+    if patch_list is not None:
+        for dim in patch_list:
+            value_ge_than_8_power_of_2(dim)

careamics/conftest.py

@@ -0,0 +1,39 @@
+"""File used to discover python modules and run doctest.
+
+See https://sybil.readthedocs.io/en/latest/use.html#pytest
+"""
+
+from pathlib import Path
+
+import pytest
+from pytest import TempPathFactory
+from sybil import Sybil
+from sybil.parsers.codeblock import PythonCodeBlockParser
+from sybil.parsers.doctest import DocTestParser
+
+
+@pytest.fixture(scope="module")
+def my_path(tmpdir_factory: TempPathFactory) -> Path:
+    """Fixture used in doctest to create a temporary directory.
+
+    Parameters
+    ----------
+    tmpdir_factory : TempPathFactory
+        Temporary path factory from pytest.
+
+    Returns
+    -------
+    Path
+        Temporary directory path.
+    """
+    return tmpdir_factory.mktemp("my_path")
+
+
+pytest_collect_file = Sybil(
+    parsers=[
+        DocTestParser(),
+        PythonCodeBlockParser(future_imports=["print_function"]),
+    ],
+    pattern="*.py",
+    fixtures=["my_path"],
+).pytest()

careamics/dataset/__init__.py

@@ -0,0 +1,17 @@
+"""Dataset module."""
+
+__all__ = [
+    "InMemoryDataset",
+    "InMemoryPredDataset",
+    "InMemoryTiledPredDataset",
+    "PathIterableDataset",
+    "IterableTiledPredDataset",
+    "IterablePredDataset",
+]
+
+from .in_memory_dataset import InMemoryDataset
+from .in_memory_pred_dataset import InMemoryPredDataset
+from .in_memory_tiled_pred_dataset import InMemoryTiledPredDataset
+from .iterable_dataset import PathIterableDataset
+from .iterable_pred_dataset import IterablePredDataset
+from .iterable_tiled_pred_dataset import IterableTiledPredDataset

careamics/dataset/dataset_utils/__init__.py

@@ -0,0 +1,19 @@
+"""Files and arrays utils used in the datasets."""
+
+__all__ = [
+    "reshape_array",
+    "compute_normalization_stats",
+    "get_files_size",
+    "list_files",
+    "validate_source_target_files",
+    "iterate_over_files",
+    "WelfordStatistics",
+]
+
+
+from .dataset_utils import (
+    reshape_array,
+)
+from .file_utils import get_files_size, list_files, validate_source_target_files
+from .iterate_over_files import iterate_over_files
+from .running_stats import WelfordStatistics, compute_normalization_stats