careamics 0.1.0rc3__py3-none-any.whl → 0.1.0rc5__py3-none-any.whl

careamics/transforms/nd_flip.py

@@ -1,93 +1,67 @@
-from typing import Any, Dict, Tuple
+from typing import Optional, Tuple
 
 import numpy as np
-from albumentations import DualTransform
 
+from careamics.transforms.transform import Transform
 
-class NDFlip(DualTransform):
+
+class NDFlip(Transform):
     """Flip ND arrays on a single axis.
 
     This transform ignores singleton axes and randomly flips one of the other
-    axes, to the exception of the first and last axes (sample and channels).
+    last two axes.
 
-    This transform expects (Z)YXC dimensions.
+    This transform expects C(Z)YX dimensions.
     """
 
-    def __init__(self, p: float = 0.5, is_3D: bool = False, flip_z: bool = True):
+    def __init__(self, seed: Optional[int] = None):
         """Constructor.
 
         Parameters
         ----------
-        p : float, optional
-            Probability to apply the transform, by default 0.5
-        is_3D : bool, optional
-            Whether the data is 3D, by default False
-        flip_z : bool, optional
-            Whether to flip Z dimension, by default True
+        seed : Optional[int], optional
+            Random seed, by default None
         """
-        super().__init__(p=p)
-
-        self.is_3D = is_3D
-        self.flip_z = flip_z
-
         # "flippable" axes
-        if is_3D:
-            self.axis_indices = [0, 1, 2] if flip_z else [1, 2]
-        else:
-            self.axis_indices = [0, 1]
+        self.axis_indices = [-2, -1]
 
-    def get_params(self, **kwargs: Any) -> Dict[str, int]:
-        """Get the transform parameters.
-
-        Returns
-        -------
-        Dict[str, int]
-            Transform parameters.
-        """
-        return {"flip_axis": np.random.choice(self.axis_indices)}
+        # numpy random generator
+        self.rng = np.random.default_rng(seed=seed)
 
-    def apply(self, patch: np.ndarray, flip_axis: int, **kwargs: Any) -> np.ndarray:
-        """Apply the transform to the image.
+    def __call__(
+        self, patch: np.ndarray, target: Optional[np.ndarray] = None
+    ) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+        """Apply the transform to the source patch and the target (optional).
 
         Parameters
         ----------
         patch : np.ndarray
-            Image or image patch, 2D or 3D, shape (y, x, c) or (z, y, x, c).
-        flip_axis : int
-            Axis along which to flip the patch.
+            Patch, 2D or 3D, shape C(Z)YX.
+        target : Optional[np.ndarray], optional
+            Target for the patch, by default None
+
+        Returns
+        -------
+        Tuple[np.ndarray, Optional[np.ndarray]]
+            Transformed patch and target.
         """
-        if len(patch.shape) == 3 and self.is_3D:
-            raise ValueError(
-                "Incompatible patch shape and dimensionality. ZYXC patch shape "
-                "expected, but got YXC shape."
-            )
+        # choose an axis to flip
+        axis = self.rng.choice(self.axis_indices)
+
+        patch_transformed = self._apply(patch, axis)
+        target_transformed = self._apply(target, axis) if target is not None else None
 
-        return np.ascontiguousarray(np.flip(patch, axis=flip_axis))
+        return patch_transformed, target_transformed
 
-    def apply_to_mask(
-        self, mask: np.ndarray, flip_axis: int, **kwargs: Any
-    ) -> np.ndarray:
-        """Apply the transform to the mask.
+    def _apply(self, patch: np.ndarray, axis: int) -> np.ndarray:
+        """Apply the transform to the image.
 
         Parameters
         ----------
-        mask : np.ndarray
-            Mask or mask patch, 2D or 3D, shape (y, x, c) or (z, y, x, c).
-        """
-        if len(mask.shape) == 3 and self.is_3D:
-            raise ValueError(
-                "Incompatible mask shape and dimensionality. ZYXC patch shape "
-                "expected, but got YXC shape."
-            )
-
-        return np.ascontiguousarray(np.flip(mask, axis=flip_axis))
-
-    def get_transform_init_args_names(self, **kwargs: Any) -> Tuple[str, ...]:
-        """Get the transform arguments names.
-
-        Returns
-        -------
-        Tuple[str, ...]
-            Transform arguments names.
+        patch : np.ndarray
+            Image or image patch, 2D or 3D, shape C(Z)YX.
+        axis : int
+            Axis to flip.
         """
-        return ("is_3D", "flip_z")
+        # TODO why ascontiguousarray?
+        return np.ascontiguousarray(np.flip(patch, axis=axis))

careamics/transforms/normalize.py

@@ -1,14 +1,15 @@
-from typing import Any
+from typing import Optional, Tuple
 
 import numpy as np
-from albumentations import DualTransform
 
+from careamics.transforms.transform import Transform
 
-class Normalize(DualTransform):
+
+class Normalize(Transform):
     """
     Normalize an image or image patch.
 
-    Normalization is a zero mean and unit variance. This transform expects (Z)YXC
+    Normalization is a zero mean and unit variance. This transform expects C(Z)YX
     dimensions.
 
     Not that an epsilon value of 1e-6 is added to the standard deviation to avoid
@@ -20,8 +21,6 @@ class Normalize(DualTransform):
         Mean value.
     std : float
         Standard deviation value.
-    eps : float
-        Epsilon value to avoid division by zero.
     """
 
     def __init__(
@@ -29,48 +28,42 @@ class Normalize(DualTransform):
         mean: float,
         std: float,
     ):
-        super().__init__(always_apply=True, p=1)
-
         self.mean = mean
         self.std = std
         self.eps = 1e-6
 
-    def apply(self, patch: np.ndarray, **kwargs: Any) -> np.ndarray:
-        """
-        Apply the transform to the image.
+    def __call__(
+        self, patch: np.ndarray, target: Optional[np.ndarray] = None
+    ) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+        """Apply the transform to the source patch and the target (optional).
 
         Parameters
         ----------
         patch : np.ndarray
-            Image or image patch, 2D or 3D, shape (y, x, c) or (z, y, x, c).
+            Patch, 2D or 3D, shape C(Z)YX.
+        target : Optional[np.ndarray], optional
+            Target for the patch, by default None
 
         Returns
         -------
-        np.ndarray
-            Normalized image or image patch.
+        Tuple[np.ndarray, Optional[np.ndarray]]
+            Transformed patch and target.
         """
-        return ((patch - self.mean) / (self.std + self.eps)).astype(np.float32)
+        norm_patch = self._apply(patch)
+        norm_target = self._apply(target) if target is not None else None
 
-    def apply_to_mask(self, mask: np.ndarray, **kwargs: Any) -> np.ndarray:
-        """
-        Apply the transform to the mask.
+        return norm_patch, norm_target
 
-        The mask is returned as is.
-
-        Parameters
-        ----------
-        mask : np.ndarray
-            Mask or mask patch, 2D or 3D, shape (y, x, c) or (z, y, x, c).
-        """
-        return mask
+    def _apply(self, patch: np.ndarray) -> np.ndarray:
+        return ((patch - self.mean) / (self.std + self.eps)).astype(np.float32)
 
 
-class Denormalize(DualTransform):
+class Denormalize:
     """
     Denormalize an image or image patch.
 
     Denormalization is performed expecting a zero mean and unit variance input. This
-    transform expects (Z)YXC dimensions.
+    transform expects C(Z)YX dimensions.
 
     Not that an epsilon value of 1e-6 is added to the standard deviation to avoid
     division by zero during the normalization step, which is taken into account during
@@ -82,8 +75,6 @@ class Denormalize(DualTransform):
         Mean value.
     std : float
         Standard deviation value.
-    eps : float
-        Epsilon value to avoid division by zero.
     """
 
     def __init__(
@@ -91,19 +82,39 @@ class Denormalize(DualTransform):
         mean: float,
         std: float,
     ):
-        super().__init__(always_apply=True, p=1)
-
         self.mean = mean
         self.std = std
         self.eps = 1e-6
 
-    def apply(self, patch: np.ndarray, **kwargs: Any) -> np.ndarray:
+    def __call__(
+        self, patch: np.ndarray, target: Optional[np.ndarray] = None
+    ) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+        """Apply the transform to the source patch and the target (optional).
+
+        Parameters
+        ----------
+        patch : np.ndarray
+            Patch, 2D or 3D, shape C(Z)YX.
+        target : Optional[np.ndarray], optional
+            Target for the patch, by default None
+
+        Returns
+        -------
+        Tuple[np.ndarray, Optional[np.ndarray]]
+            Transformed patch and target.
+        """
+        norm_patch = self._apply(patch)
+        norm_target = self._apply(target) if target is not None else None
+
+        return norm_patch, norm_target
+
+    def _apply(self, patch: np.ndarray) -> np.ndarray:
         """
         Apply the transform to the image.
 
         Parameters
         ----------
         patch : np.ndarray
-            Image or image patch, 2D or 3D, shape (y, x, c) or (z, y, x, c).
+            Image or image patch, 2D or 3D, shape C(Z)YX.
         """
         return patch * (self.std + self.eps) + self.mean

careamics/transforms/pixel_manipulation.py

@@ -4,6 +4,7 @@ Pixel manipulation methods.
 Pixel manipulation is used in N2V and similar algorithm to replace the value of
 masked pixels.
 """
+
 from typing import Optional, Tuple, Union
 
 import numpy as np
@@ -246,8 +247,7 @@ def uniform_manipulate(
     subpatch_size : int
         Size of the subpatch the new pixel value is sampled from, by default 11.
     remove_center : bool
-        Whether to remove the center pixel from the subpatch, by default False. See
-        uniform with/without central pixel in the documentation. #TODO add link
+        Whether to remove the center pixel from the subpatch, by default False.
     struct_params: Optional[StructMaskParameters]
         Parameters for the structN2V mask (axis and span).
 

careamics/transforms/transform.py

@@ -0,0 +1,33 @@
+"""A general parent class for transforms."""
+
+from typing import Optional, Tuple
+
+import numpy as np
+
+
+class Transform:
+    """A general parent class for transforms."""
+
+    def __call__(
+        self, patch: np.ndarray, target: Optional[np.ndarray] = None
+    ) -> Tuple[np.ndarray, ...]:
+        """Apply the transform to the input data.
+
+        Parameters
+        ----------
+        patch : np.ndarray
+            The input data to transform.
+        target : Optional[np.ndarray], optional
+            The target data to transform, by default None
+
+        Returns
+        -------
+        Tuple[np.ndarray, ...]
+            The output of the transformations.
+
+        Raises
+        ------
+        NotImplementedError
+            This method should be implemented in the child class.
+        """
+        raise NotImplementedError

careamics/transforms/tta.py

@@ -1,7 +1,7 @@
 """Test-time augmentations."""
+
 from typing import List
 
-import numpy as np
 from torch import Tensor, flip, mean, rot90, stack
 
 
@@ -48,7 +48,7 @@ class ImageRestorationTTA:
             augmented_flip.append(flip(x_, dims=(-3, -1)))
         return augmented_flip
 
-    def backward(self, x: List[Tensor]) -> np.ndarray:
+    def backward(self, x: List[Tensor]) -> Tensor:
         """Undo the test-time augmentation.
 
         Parameters

careamics/transforms/xy_random_rotate90.py

@@ -1,95 +1,68 @@
-from typing import Any, Dict, Tuple
+from typing import Optional, Tuple
 
 import numpy as np
-from albumentations import DualTransform
 
+from careamics.transforms.transform import Transform
 
-class XYRandomRotate90(DualTransform):
-    """Applies random 90 degree rotations to the YX axis.
 
-    This transform expects (Z)YXC dimensions.
+class XYRandomRotate90(Transform):
+    """Applies random 90 degree rotations to the YX axis.
 
-    Parameters
-    ----------
-    p : int, optional
-        Probability to apply the transform, by default 0.5
-    is_3D : bool, optional
-        Whether the patches are 3D, by default False
+    This transform expects C(Z)YX dimensions.
     """
 
-    def __init__(self, p: float = 0.5, is_3D: bool = False):
+    def __init__(self, seed: Optional[int] = None):
         """Constructor.
 
         Parameters
         ----------
-        p : float, optional
-            Probability to apply the transform, by default 0.5
-        is_3D : bool, optional
-            Whether the patches are 3D, by default False
+        seed : Optional[int], optional
+            Random seed, by default None
         """
-        super().__init__(p=p)
-
-        self.is_3D = is_3D
+        # numpy random generator
+        self.rng = np.random.default_rng(seed=seed)
 
-        # rotation axes
-        if is_3D:
-            self.axes = (1, 2)
-        else:
-            self.axes = (0, 1)
+    def __call__(
+        self, patch: np.ndarray, target: Optional[np.ndarray] = None
+    ) -> Tuple[np.ndarray, Optional[np.ndarray]]:
+        """Apply the transform to the source patch and the target (optional).
 
-    def get_params(self, **kwargs: Any) -> Dict[str, int]:
-        """Get the transform parameters.
+        Parameters
+        ----------
+        patch : np.ndarray
+            Patch, 2D or 3D, shape C(Z)YX.
+        target : Optional[np.ndarray], optional
+            Target for the patch, by default None
 
         Returns
         -------
-        Dict[str, int]
-            Transform parameters.
+        Tuple[np.ndarray, Optional[np.ndarray]]
+            Transformed patch and target.
         """
-        return {"n_rotations": np.random.randint(1, 4)}
+        # number of rotations
+        n_rot = self.rng.integers(1, 4)
 
-    def apply(self, patch: np.ndarray, n_rotations: int, **kwargs: Any) -> np.ndarray:
-        """Apply the transform to the image.
+        axes = (-2, -1)
+        patch_transformed = self._apply(patch, n_rot, axes)
+        target_transformed = (
+            self._apply(target, n_rot, axes) if target is not None else None
+        )
 
-        Parameters
-        ----------
-        patch : np.ndarray
-            Image or image patch, 2D or 3D, shape (y, x, c) or (z, y, x, c).
-        flip_axis : int
-            Axis along which to flip the patch.
-        """
-        if len(patch.shape) == 3 and self.is_3D:
-            raise ValueError(
-                "Incompatible patch shape and dimensionality. ZYXC patch shape "
-                "expected, but got YXC shape."
-            )
+        return patch_transformed, target_transformed
 
-        return np.ascontiguousarray(np.rot90(patch, k=n_rotations, axes=self.axes))
-
-    def apply_to_mask(
-        self, mask: np.ndarray, n_rotations: int, **kwargs: Any
+    def _apply(
+        self, patch: np.ndarray, n_rot: int, axes: Tuple[int, int]
     ) -> np.ndarray:
-        """Apply the transform to the mask.
+        """Apply the transform to the image.
 
         Parameters
         ----------
-        mask : np.ndarray
-            Mask or mask patch, 2D or 3D, shape (y, x, c) or (z, y, x, c).
-        """
-        if len(mask.shape) != 4 and self.is_3D:
-            raise ValueError(
-                "Incompatible mask shape and dimensionality. ZYXC patch shape "
-                "expected, but got YXC shape."
-            )
-
-        return np.ascontiguousarray(np.rot90(mask, k=n_rotations, axes=self.axes))
-
-    def get_transform_init_args_names(self) -> Tuple[str, str]:
-        """
-        Get the transform arguments.
-
-        Returns
-        -------
-        Tuple[str]
-            Transform arguments.
+        patch : np.ndarray
+            Image or image patch, 2D or 3D, shape C(Z)YX.
+        n_rot : int
+            Number of 90 degree rotations.
+        axes : Tuple[int, int]
+            Axes along which to rotate the patch.
         """
-        return ("p", "is_3D")
+        # TODO why ascontiguousarray?
+        return np.ascontiguousarray(np.rot90(patch, k=n_rot, axes=axes))

careamics/utils/__init__.py

@@ -1,6 +1,5 @@
 """Utils module."""
 
-
 __all__ = [
     "cwd",
     "get_ram_size",

careamics/utils/context.py

@@ -3,6 +3,7 @@ Context submodule.
 
 A convenience function to change the working directory in order to save data.
 """
+
 import os
 from contextlib import contextmanager
 from pathlib import Path

careamics/utils/logging.py

@@ -3,6 +3,7 @@ Logging submodule.
 
 The methods are responsible for the in-console logger.
 """
+
 import logging
 import sys
 import time

careamics/utils/metrics.py

@@ -3,6 +3,7 @@ Metrics submodule.
 
 This module contains various metrics and a metrics tracking class.
 """
+
 from typing import Union
 
 import numpy as np

careamics/utils/torch_utils.py

@@ -3,6 +3,7 @@ Convenience functions using torch.
 
 These functions are used to control certain aspects and behaviours of PyTorch.
 """
+
 import inspect
 from typing import Dict, Union
 

{careamics-0.1.0rc3.dist-info → careamics-0.1.0rc5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: careamics
-Version: 0.1.0rc3
+Version: 0.1.0rc5
 Summary: Toolbox for running N2V and friends.
 Project-URL: homepage, https://careamics.github.io/
 Project-URL: repository, https://github.com/CAREamics/careamics
@@ -16,7 +16,6 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Typing :: Typed
 Requires-Python: >=3.8
-Requires-Dist: albumentations
 Requires-Dist: bioimageio-core>=0.6.0
 Requires-Dist: psutil
 Requires-Dist: pydantic>=2.5
@@ -48,7 +47,7 @@ Description-Content-Type: text/markdown
   </a>
 </p>
 
-# CAREamics Restoration
+# 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)
@@ -56,67 +55,23 @@ Description-Content-Type: text/markdown
 [![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)
 
-## Installation
 
-``` bash
-pip install careamics
-```
-For more details on the options please follow the installation [guide](https://careamics.github.io/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.).
 
-## Usage
+## Why CAREamics?
 
-CAREamics uses the Engine object to construct the pipeline for both training and prediction. First we import the Engine.
-```python
-from careamics_restoration.engine import Engine
-```
-The Engine could be initialized in 2 ways:
-1. Using the [yaml config](examples/n2v_2D_reference.yml) file
+Noise2Void is a widely used denoising algorithm, and is readily available from the `n2v`
+python package. However, n2v is based on TensorFlow and Keras and we found it 
+increasingly hard to maintain. In addition, more recent methods (PPN2V, DivNoising,
+HDN) are all implemented in PyTorch, but are lacking the extra features that would make
+them usable by the community.
 
-Specify the mandatory parameters in the config file
-```yaml
-experiment_name: Name of the experiment
-working_directory: Path to the working directory, where all the outputs will be stored
+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.
 
-algorithm: 
-    loss: type of loss function, e.g. n2v for Noise2Void
-    model: model architecture, e.g. UNet
-    is_3D: True if 3D data, False if 2D data
-
-training:
-  num_epochs: Number of training epochs
-  patch_size: Size of the patches, List of 2 or 3 elements
-  batch_size: Batch size for training
-
-extraction_strategy: Controls how the patches are extracted from the data
-
-data:
-    data_format: File extension, e.g. tif
-    axes: Defines the shape of the input data
-```
-Full description of the configuration parameters is in the [documentation](https://careamics.github.io/careamics/).
-
-
-```python
-engine = Engine(config_path="config.yml")
-
-```
-2. Using the path to the pretrained model
-It's also possible to initialize the Engine using the model checkpoint, saved during the training or downloaded from the [BioImage Model Zoo](https://bioimage.io/#/).
-Checkpoint must contain model_state_dict.
-Read more abount saving and loading models in the [documentation](https://careamics.github.io/careamics/).
-
-Once Engine is initialized, we can start training, providing the relative paths to train and validation data
-
-```python
-engine.train(train_path=train_path, val_path=val_path)
-```
-Training will run for the specified number of epochs and save the model checkpoint in the working directory.
-
-Prediction could be done directly after the training or by loading the pretrained model checkpoint.
-
-```python
-predictions = engine.predict(pred_path=predict_path)
-```
-
-For more examples please take a look at the [notebooks](examples).
+## Installation and use
 
+Check out the [documentation](https://careamics.github.io/) for installation instructions and guides!