careamics 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

careamics/config/support/supported_data.py

@@ -16,12 +16,15 @@ class SupportedData(str, BaseEnum):
         Array data.
     TIFF : str
         TIFF image data.
+    CZI : str
+        CZI image data.
     CUSTOM : str
         Custom data.
     """
 
     ARRAY = "array"
     TIFF = "tiff"
+    CZI = "czi"
     CUSTOM = "custom"
     # ZARR = "zarr"
 
@@ -78,6 +81,8 @@ class SupportedData(str, BaseEnum):
             raise NotImplementedError(f"Data '{data_type}' is not loaded from a file.")
         elif data_type == cls.TIFF:
             return "*.tif*"
+        elif data_type == cls.CZI:
+            return "*.czi"
         elif data_type == cls.CUSTOM:
             return "*.*"
         else:
@@ -102,6 +107,8 @@ class SupportedData(str, BaseEnum):
             raise NotImplementedError(f"Data '{data_type}' is not loaded from a file.")
         elif data_type == cls.TIFF:
             return ".tiff"
+        elif data_type == cls.CZI:
+            return ".czi"
         elif data_type == cls.CUSTOM:
             # TODO: improve this message
             raise NotImplementedError("Custom extensions have to be passed elsewhere.")

careamics/config/support/supported_patching_strategies.py

@@ -0,0 +1,22 @@
+"""Patching strategies supported by Careamics."""
+
+from careamics.utils import BaseEnum
+
+
+class SupportedPatchingStrategy(str, BaseEnum):
+    """Patching strategies supported by Careamics."""
+
+    FIXED_RANDOM = "fixed_random"
+    """Fixed random patching strategy, used during training."""
+
+    RANDOM = "random"
+    """Random patching strategy, used during training."""
+
+    # SEQUENTIAL = "sequential"
+    # """Sequential patching strategy, used during training."""
+
+    TILED = "tiled"
+    """Tiled patching strategy, used during prediction."""
+
+    WHOLE = "whole"
+    """Whole image patching strategy, used during prediction."""

careamics/config/validators/validator_utils.py

@@ -4,7 +4,8 @@ Validator functions.
 These functions are used to validate dimensions and axes of inputs.
 """
 
-from typing import Optional, Union
+from collections.abc import Sequence
+from typing import Optional
 
 _AXES = "STCZYX"
 
@@ -79,14 +80,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[Sequence[int]],
 ) -> None:
     """
     Validate that each entry is greater or equal than 8 and a power of 2.
 
     Parameters
     ----------
-    patch_list : list or typle of int, or None
+    patch_list : Sequence of int, or None
         Patch size.
 
     Raises

careamics/dataset/dataset_utils/iterate_over_files.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from pathlib import Path
-from typing import Callable, Optional, Union
+from typing import Optional, Union
 
 from numpy.typing import NDArray
 from torch.utils.data import get_worker_info

careamics/dataset/in_memory_dataset.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import copy
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable, Optional, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 from torch.utils.data import Dataset

careamics/dataset/iterable_dataset.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 import copy
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Optional
 
 import numpy as np
 from torch.utils.data import IterableDataset

careamics/dataset/iterable_pred_dataset.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 from numpy.typing import NDArray
 from torch.utils.data import IterableDataset

careamics/dataset/iterable_tiled_pred_dataset.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 from numpy.typing import NDArray
 from torch.utils.data import IterableDataset

careamics/dataset/patching/patching.py

@@ -1,8 +1,9 @@
 """Patching functions."""
 
+from collections.abc import Callable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Callable, Union
+from typing import Union
 
 import numpy as np
 from numpy.typing import NDArray
@@ -89,7 +90,7 @@ def prepare_patches_supervised(
     """
     means, stds, num_samples = 0, 0, 0
     all_patches, all_targets = [], []
-    for train_filename, target_filename in zip(train_files, target_files):
+    for train_filename, target_filename in zip(train_files, target_files, strict=False):
         try:
             sample: np.ndarray = read_source_func(train_filename, axes)
             target: np.ndarray = read_source_func(target_filename, axes)

careamics/dataset/tiling/lvae_tiled_patching.py

@@ -78,7 +78,9 @@ def extract_tiles(
                 ...,
                 *[
                     slice(coords, coords + extent)
-                    for coords, extent in zip(crop_coords_start, tile_size)
+                    for coords, extent in zip(
+                        crop_coords_start, tile_size, strict=False
+                    )
                 ],
             )
             tile = sample[crop_slices]
@@ -159,11 +161,14 @@ def compute_tile_info_legacy(
 
     # --- combine start and end
     stitch_coords = tuple(
-        (start, end) for start, end in zip(stitch_coords_start, stitch_coords_end)
+        (start, end)
+        for start, end in zip(stitch_coords_start, stitch_coords_end, strict=False)
     )
     overlap_crop_coords = tuple(
         (start, end)
-        for start, end in zip(overlap_crop_coords_start, overlap_crop_coords_end)
+        for start, end in zip(
+            overlap_crop_coords_start, overlap_crop_coords_end, strict=False
+        )
     )
 
     tile_info = TileInformation(
@@ -229,11 +234,14 @@ def compute_tile_info(
 
     # --- combine start and end
     stitch_coords = tuple(
-        (start, end) for start, end in zip(stitch_coords_start, stitch_coords_end)
+        (start, end)
+        for start, end in zip(stitch_coords_start, stitch_coords_end, strict=False)
     )
     overlap_crop_coords = tuple(
         (start, end)
-        for start, end in zip(overlap_crop_coords_start, overlap_crop_coords_end)
+        for start, end in zip(
+            overlap_crop_coords_start, overlap_crop_coords_end, strict=False
+        )
     )
 
     # --- Check if last tile
@@ -284,7 +292,9 @@ def compute_padding(
     pad_before = overlaps // 2
     pad_after = covered_shape - data_shape[-len(tile_size) :] - pad_before
 
-    return tuple((before, after) for before, after in zip(pad_before, pad_after))
+    return tuple(
+        (before, after) for before, after in zip(pad_before, pad_after, strict=False)
+    )
 
 
 def n_tiles_1d(axis_size: int, tile_size: int, overlap: int) -> int:

careamics/dataset/tiling/tiled_patching.py

@@ -127,7 +127,7 @@ def extract_tiles(
         # Rearrange crop coordinates from a list of coordinate pairs per axis to a list
         # grouped by type.
         all_crop_coords, all_stitch_coords, all_overlap_crop_coords = zip(
-            *crop_and_stitch_coords_list
+            *crop_and_stitch_coords_list, strict=False
         )
 
         # Maximum tile index
@@ -139,6 +139,7 @@ def extract_tiles(
                 itertools.product(*all_crop_coords),
                 itertools.product(*all_stitch_coords),
                 itertools.product(*all_overlap_crop_coords),
+                strict=False,
             )
         ):
             # Extract tile from the sample

careamics/dataset_ng/dataset.py

@@ -8,7 +8,10 @@ from numpy.typing import NDArray
 from torch.utils.data import Dataset
 from tqdm.auto import tqdm
 
-from careamics.config import DataConfig, InferenceConfig
+from careamics.config.data.ng_data_model import NGDataConfig
+from careamics.config.support.supported_patching_strategies import (
+    SupportedPatchingStrategy,
+)
 from careamics.config.transformations import NormalizeModel
 from careamics.dataset.dataset_utils.running_stats import WelfordStatistics
 from careamics.dataset.patching.patching import Stats
@@ -45,7 +48,7 @@ InputType = Union[Sequence[NDArray[Any]], Sequence[Path]]
 class CareamicsDataset(Dataset, Generic[GenericImageStack]):
     def __init__(
         self,
-        data_config: Union[DataConfig, InferenceConfig],
+        data_config: NGDataConfig,
         mode: Mode,
         input_extractor: PatchExtractor[GenericImageStack],
         target_extractor: Optional[PatchExtractor[GenericImageStack]] = None,
@@ -65,33 +68,43 @@ class CareamicsDataset(Dataset, Generic[GenericImageStack]):
     def _initialize_patching_strategy(self) -> PatchingStrategy:
         patching_strategy: PatchingStrategy
         if self.mode == Mode.TRAINING:
-            if isinstance(self.config, InferenceConfig):
-                raise ValueError("Inference config cannot be used for training.")
+            if self.config.patching.name != SupportedPatchingStrategy.RANDOM:
+                raise ValueError(
+                    f"Only `random` patching strategy supported during training, got "
+                    f"{self.config.patching.name}."
+                )
+
             patching_strategy = RandomPatchingStrategy(
                 data_shapes=self.input_extractor.shape,
-                patch_size=self.config.patch_size,
-                # TODO: Add random seed to dataconfig
-                seed=getattr(self.config, "random_seed", 42),
+                patch_size=self.config.patching.patch_size,
+                seed=self.config.seed,
             )
         elif self.mode == Mode.VALIDATING:
-            if isinstance(self.config, InferenceConfig):
-                raise ValueError("Inference config cannot be used for validating.")
+            if self.config.patching.name != SupportedPatchingStrategy.RANDOM:
+                raise ValueError(
+                    f"Only `random` patching strategy supported during training, got "
+                    f"{self.config.patching.name}."
+                )
+
             patching_strategy = FixedRandomPatchingStrategy(
                 data_shapes=self.input_extractor.shape,
-                patch_size=self.config.patch_size,
-                # TODO: Add random seed to dataconfig
-                seed=getattr(self.config, "random_seed", 42),
+                patch_size=self.config.patching.patch_size,
+                seed=self.config.seed,
             )
         elif self.mode == Mode.PREDICTING:
-            if not isinstance(self.config, InferenceConfig):
-                raise ValueError("Inference config must be used for predicting.")
-            if (self.config.tile_size is not None) and (
-                self.config.tile_overlap is not None
+            if (
+                self.config.patching.name != SupportedPatchingStrategy.TILED
+                and self.config.patching.name != SupportedPatchingStrategy.WHOLE
             ):
+                raise ValueError(
+                    f"Only `tiled` and `whole` patching strategy supported during "
+                    f"training, got {self.config.patching.name}."
+                )
+            elif self.config.patching.name == SupportedPatchingStrategy.TILED:
                 patching_strategy = TilingStrategy(
                     data_shapes=self.input_extractor.shape,
-                    tile_size=self.config.tile_size,
-                    overlaps=self.config.tile_overlap,
+                    tile_size=self.config.patching.patch_size,
+                    overlaps=self.config.patching.overlaps,
                 )
             else:
                 patching_strategy = WholeSamplePatchingStrategy(
@@ -103,32 +116,18 @@ class CareamicsDataset(Dataset, Generic[GenericImageStack]):
         return patching_strategy
 
     def _initialize_transforms(self) -> Optional[Compose]:
-        if isinstance(self.config, DataConfig):
-            if self.mode == Mode.TRAINING:
-                # TODO: initialize normalization separately depending on configuration
-                return Compose(
-                    transform_list=[
-                        NormalizeModel(
-                            image_means=self.input_stats.means,
-                            image_stds=self.input_stats.stds,
-                            target_means=self.target_stats.means,
-                            target_stds=self.target_stats.stds,
-                        )
-                    ]
-                    + list(self.config.transforms)
-                )
+        normalize = NormalizeModel(
+            image_means=self.input_stats.means,
+            image_stds=self.input_stats.stds,
+            target_means=self.target_stats.means,
+            target_stds=self.target_stats.stds,
+        )
+        if self.mode == Mode.TRAINING:
+            # TODO: initialize normalization separately depending on configuration
+            return Compose(transform_list=[normalize] + list(self.config.transforms))
 
         # TODO: add TTA
-        return Compose(
-            transform_list=[
-                NormalizeModel(
-                    image_means=self.input_stats.means,
-                    image_stds=self.input_stats.stds,
-                    target_means=self.target_stats.means,
-                    target_stds=self.target_stats.stds,
-                )
-            ]
-        )
+        return Compose(transform_list=[normalize])
 
     def _calculate_stats(
         self, data_extractor: PatchExtractor[GenericImageStack]
@@ -158,14 +157,11 @@ class CareamicsDataset(Dataset, Generic[GenericImageStack]):
             input_stats = self._calculate_stats(self.input_extractor)
 
         target_stats = Stats((), ())
-        if isinstance(self.config, DataConfig):
-            if (
-                self.config.target_means is not None
-                and self.config.target_stds is not None
-            ):
-                target_stats = Stats(self.config.target_means, self.config.target_stds)
-            elif self.target_extractor is not None:
-                target_stats = self._calculate_stats(self.target_extractor)
+
+        if self.config.target_means is not None and self.config.target_stds is not None:
+            target_stats = Stats(self.config.target_means, self.config.target_stds)
+        elif self.target_extractor is not None:
+            target_stats = self._calculate_stats(self.target_extractor)
 
         return input_stats, target_stats
 

careamics/dataset_ng/demos/bsd68_demo.ipynb

@@ -13,8 +13,11 @@
     "import tifffile\n",
     "from careamics_portfolio import PortfolioManager\n",
     "\n",
-    "from careamics.config.configuration_factories import create_n2v_configuration\n",
-    "from careamics.config.support import SupportedTransform\n",
+    "from careamics.config.configuration_factories import (\n",
+    "    _create_ng_data_configuration,\n",
+    "    create_n2v_configuration,\n",
+    ")\n",
+    "from careamics.config.data import NGDataConfig\n",
     "from careamics.lightning.callbacks import HyperParametersCallback\n",
     "from careamics.lightning.dataset_ng.data_module import CareamicsDataModule\n",
     "from careamics.lightning.dataset_ng.lightning_modules import N2VModule"
@@ -29,7 +32,8 @@
     "# Set seeds for reproducibility\n",
     "from pytorch_lightning import seed_everything\n",
     "\n",
-    "seed_everything(42)"
+    "seed = 42\n",
+    "seed_everything(seed)"
    ]
   },
   {
@@ -110,17 +114,17 @@
     "    num_epochs=100,\n",
     ")\n",
     "\n",
-    "# Ensuring that transforms are set\n",
-    "config.data_config.transforms = [\n",
-    "    {\n",
-    "        \"name\": SupportedTransform.XY_FLIP.value,\n",
-    "        \"flip_x\": True,\n",
-    "        \"flip_y\": True,\n",
-    "    },\n",
-    "    {\n",
-    "        \"name\": SupportedTransform.XY_RANDOM_ROTATE90.value,\n",
-    "    },\n",
-    "]"
+    "# TODO until the NGDataConfig is accepted by the Confiugration, these are separte\n",
+    "ng_data_config = _create_ng_data_configuration(\n",
+    "    data_type=config.data_config.data_type,\n",
+    "    axes=config.data_config.axes,\n",
+    "    patch_size=config.data_config.patch_size,\n",
+    "    batch_size=config.data_config.batch_size,\n",
+    "    augmentations=config.data_config.transforms,\n",
+    "    train_dataloader_params=config.data_config.train_dataloader_params,\n",
+    "    val_dataloader_params=config.data_config.val_dataloader_params,\n",
+    "    seed=seed,\n",
+    ")\n"
    ]
   },
   {
@@ -137,7 +141,7 @@
    "outputs": [],
    "source": [
     "train_data_module = CareamicsDataModule(\n",
-    "    data_config=config.data_config,\n",
+    "    data_config=ng_data_config,\n",
     "    train_data=train_files,\n",
     "    val_data=val_files,\n",
     ")\n",
@@ -224,15 +228,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from careamics.config.inference_model import InferenceConfig\n",
     "from careamics.dataset_ng.legacy_interoperability import imageregions_to_tileinfos\n",
     "from careamics.prediction_utils import convert_outputs\n",
     "\n",
-    "config = InferenceConfig(\n",
-    "    model_config=config,\n",
+    "config = NGDataConfig(\n",
     "    data_type=\"tiff\",\n",
-    "    tile_size=(128, 128),\n",
-    "    tile_overlap=(32, 32),\n",
+    "    patching={\n",
+    "        \"name\": \"tiled\",\n",
+    "        \"patch_size\": (128, 128),\n",
+    "        \"overlaps\": (32, 32),\n",
+    "    },\n",
     "    axes=\"YX\",\n",
     "    batch_size=1,\n",
     "    image_means=train_data_module.train_dataset.input_stats.means,\n",
@@ -319,7 +324,7 @@
     "psnrs = np.zeros((len(predictions), 1))\n",
     "scale_invariant_psnrs = np.zeros((len(predictions), 1))\n",
     "\n",
-    "for i, (pred, gt) in enumerate(zip(predictions, gts)):\n",
+    "for i, (pred, gt) in enumerate(zip(predictions, gts, strict=False)):\n",
     "    psnrs[i] = psnr(gt, pred.squeeze(), data_range=gt.max() - gt.min())\n",
     "    scale_invariant_psnrs[i] = scale_invariant_psnr(gt, pred.squeeze())\n",
     "\n",
@@ -334,7 +339,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "czi",
    "language": "python",
    "name": "python3"
   },
@@ -348,7 +353,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.14"
+   "version": "3.12.11"
   }
  },
  "nbformat": 4,

careamics/dataset_ng/demos/care_U2OS_demo.ipynb

@@ -293,7 +293,7 @@
     "psnrs = np.zeros((len(prediction), 1))\n",
     "scale_invariant_psnrs = np.zeros((len(prediction), 1))\n",
     "\n",
-    "for i, (pred, gt) in enumerate(zip(prediction, gts)):\n",
+    "for i, (pred, gt) in enumerate(zip(prediction, gts, strict=False)):\n",
     "    psnrs[i] = psnr(gt, pred.squeeze(), data_range=gt.max() - gt.min())\n",
     "    scale_invariant_psnrs[i] = scale_invariant_psnr(gt, pred.squeeze())\n",
     "\n",

careamics/dataset_ng/demos/demo_custom_image_stack.ipynb

@@ -698,7 +698,7 @@
     "psnrs = np.zeros((len(prediction), 1))\n",
     "scale_invariant_psnrs = np.zeros((len(prediction), 1))\n",
     "\n",
-    "for i, (pred, gt) in enumerate(zip(prediction, gts)):\n",
+    "for i, (pred, gt) in enumerate(zip(prediction, gts, strict=False)):\n",
     "    psnrs[i] = psnr(gt, pred.squeeze(), data_range=gt.max() - gt.min())\n",
     "    scale_invariant_psnrs[i] = scale_invariant_psnr(gt, pred.squeeze())\n",
     "\n",