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

careamics/config/noise_models.py

@@ -1,162 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Dict, Union
-
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-
-
-class NoiseModelType(str, Enum):
-    """
-    Available noise models.
-
-    Currently supported noise models:
-
-        - hist: Histogram noise model.
-        - gmm: Gaussian mixture model noise model.F
-    """
-
-    NONE = "none"
-    HIST = "hist"
-    GMM = "gmm"
-
-    # TODO add validator decorator
-    @classmethod
-    def validate_noise_model_type(
-        cls, noise_model: Union[str, NoiseModel], parameters: dict
-    ) -> None:
-        """_summary_.
-
-        Parameters
-        ----------
-        noise_model : Union[str, NoiseModel]
-            _description_
-        parameters : dict
-            _description_
-
-        Returns
-        -------
-        BaseModel
-            _description_
-        """
-        if noise_model == NoiseModelType.HIST.value:
-            HistogramNoiseModel(**parameters)
-            return HistogramNoiseModel().model_dump() if not parameters else parameters
-
-        elif noise_model == NoiseModelType.GMM.value:
-            GaussianMixtureNoiseModel(**parameters)
-            return (
-                GaussianMixtureNoiseModel().model_dump()
-                if not parameters
-                else parameters
-            )
-
-
-class NoiseModel(BaseModel):
-    """_summary_.
-
-    Parameters
-    ----------
-    BaseModel : _type_
-        _description_
-
-    Returns
-    -------
-    _type_
-        _description_
-
-    Raises
-    ------
-    ValueError
-        _description_
-    """
-
-    model_config = ConfigDict(
-        use_enum_values=True,
-        protected_namespaces=(),  # allows to use model_* as a field name
-        validate_assignment=True,
-    )
-
-    model_type: NoiseModelType
-    parameters: Dict = Field(default_factory=dict, validate_default=True)
-
-    @field_validator("parameters")
-    @classmethod
-    def validate_parameters(cls, data, values) -> Dict:
-        """_summary_.
-
-        Parameters
-        ----------
-        parameters : Dict
-            _description_
-
-        Returns
-        -------
-        Dict
-            _description_
-        """
-        if values.data["model_type"] not in [NoiseModelType.GMM, NoiseModelType.HIST]:
-            raise ValueError(
-                f"Incorrect noise model {values.data['model_type']}."
-                f"Please refer to the documentation"  # TODO add link to documentation
-            )
-
-        parameters = NoiseModelType.validate_noise_model_type(
-            values.data["model_type"], data
-        )
-        return parameters
-
-
-class HistogramNoiseModel(BaseModel):
-    """
-    Histogram noise model.
-
-    Attributes
-    ----------
-    min_value : float
-        Minimum value in the input.
-    max_value : float
-        Maximum value in the input.
-    bins : int
-        Number of bins of the histogram.
-    """
-
-    min_value: float = Field(default=350.0, ge=0.0, le=65535.0)
-    max_value: float = Field(default=6500.0, ge=0.0, le=65535.0)
-    bins: int = Field(default=256, ge=1)
-
-
-class GaussianMixtureNoiseModel(BaseModel):
-    """
-    Gaussian mixture model noise model.
-
-    Attributes
-    ----------
-    min_signal : float
-    Minimum signal intensity expected in the image.
-    max_signal : float
-    Maximum signal intensity expected in the image.
-    weight : array
-    A [3*n_gaussian, n_coeff] sized array containing the values of the weights
-    describing the noise model.
-    Each gaussian contributes three parameters (mean, standard deviation and weight),
-    hence the number of rows in `weight` are 3*n_gaussian.
-    If `weight = None`, the weight array is initialized using the `min_signal` and
-    `max_signal` parameters.
-    n_gaussian: int
-    Number of gaussians.
-    n_coeff: int
-    Number of coefficients to describe the functional relationship between gaussian
-    parameters and the signal.
-    2 implies a linear relationship, 3 implies a quadratic relationship and so on.
-    device: device
-    GPU device.
-    min_sigma: int
-    """
-
-    num_components: int = Field(default=3, ge=1)
-    min_value: float = Field(default=350.0, ge=0.0, le=65535.0)
-    max_value: float = Field(default=6500.0, ge=0.0, le=65535.0)
-    n_gaussian: int = Field(default=3, ge=1)
-    n_coeff: int = Field(default=2, ge=1)
-    min_sigma: int = Field(default=50, ge=1)

careamics/config/support/supported_extraction_strategies.py

@@ -1,25 +0,0 @@
-"""
-Extraction strategy module.
-
-This module defines the various extraction strategies available in CAREamics.
-"""
-
-from careamics.utils import BaseEnum
-
-
-class SupportedExtractionStrategy(str, BaseEnum):
-    """
-    Available extraction strategies.
-
-    Currently supported:
-        - random: random extraction.
-        # TODO
-        - sequential: grid extraction, can miss edge values.
-        - tiled: tiled extraction, covers the whole image.
-    """
-
-    RANDOM = "random"
-    RANDOM_ZARR = "random_zarr"
-    SEQUENTIAL = "sequential"
-    TILED = "tiled"
-    NONE = "none"

careamics/config/transformations/nd_flip_model.py

@@ -1,27 +0,0 @@
-"""Pydantic model for the NDFlip transform."""
-
-from typing import Literal, Optional
-
-from pydantic import ConfigDict
-
-from .transform_model import TransformModel
-
-
-class NDFlipModel(TransformModel):
-    """
-    Pydantic model used to represent NDFlip transformation.
-
-    Attributes
-    ----------
-    name : Literal["NDFlip"]
-        Name of the transformation.
-    seed : Optional[int]
-        Seed for the random number generator.
-    """
-
-    model_config = ConfigDict(
-        validate_assignment=True,
-    )
-
-    name: Literal["NDFlip"] = "NDFlip"
-    seed: Optional[int] = None

careamics/lightning_prediction_loop.py

@@ -1,116 +0,0 @@
-from typing import Optional
-
-import pytorch_lightning as L
-from pytorch_lightning.loops.fetchers import _DataLoaderIterDataFetcher
-from pytorch_lightning.loops.utilities import _no_grad_context
-from pytorch_lightning.trainer import call
-from pytorch_lightning.utilities.types import _PREDICT_OUTPUT
-
-from careamics.prediction import stitch_prediction
-
-
-class CAREamicsPredictionLoop(L.loops._PredictionLoop):
-    """
-    CAREamics prediction loop.
-
-    This class extends the PyTorch Lightning `_PredictionLoop` class to include
-    the stitching of the tiles into a single prediction result.
-    """
-
-    def _on_predict_epoch_end(self) -> Optional[_PREDICT_OUTPUT]:
-        """
-        Calls `on_predict_epoch_end` hook.
-
-        Adapted from the parent method.
-
-        Returns
-        -------
-            the results for all dataloaders
-        """
-        trainer = self.trainer
-        call._call_callback_hooks(trainer, "on_predict_epoch_end")
-        call._call_lightning_module_hook(trainer, "on_predict_epoch_end")
-
-        if self.return_predictions:
-            ########################################################
-            ################ CAREamics specific code ###############
-            if len(self.predicted_array) == 1:
-                # TODO does this make sense to here? (force numpy array)
-                return self.predicted_array[0].numpy()
-            else:
-                # TODO revisit logic
-                return [element.numpy() for element in self.predicted_array]
-            ########################################################
-        return None
-
-    @_no_grad_context
-    def run(self) -> Optional[_PREDICT_OUTPUT]:
-        """
-        Runs the prediction loop.
-
-        Adapted from the parent method in order to stitch the predictions.
-
-        Returns
-        -------
-        Optional[_PREDICT_OUTPUT]
-            Prediction output
-        """
-        self.setup_data()
-        if self.skip:
-            return None
-        self.reset()
-        self.on_run_start()
-        data_fetcher = self._data_fetcher
-        assert data_fetcher is not None
-
-        self.predicted_array = []
-        self.tiles = []
-        self.stitching_data = []
-
-        while True:
-            try:
-                if isinstance(data_fetcher, _DataLoaderIterDataFetcher):
-                    dataloader_iter = next(data_fetcher)
-                    # hook's batch_idx and dataloader_idx arguments correctness cannot
-                    # be guaranteed in this setting
-                    batch = data_fetcher._batch
-                    batch_idx = data_fetcher._batch_idx
-                    dataloader_idx = data_fetcher._dataloader_idx
-                else:
-                    dataloader_iter = None
-                    batch, batch_idx, dataloader_idx = next(data_fetcher)
-                self.batch_progress.is_last_batch = data_fetcher.done
-
-                # run step hooks
-                self._predict_step(batch, batch_idx, dataloader_idx, dataloader_iter)
-
-                ########################################################
-                ################ CAREamics specific code ###############
-                is_tiled = len(self.predictions[batch_idx]) == 2
-                if is_tiled:
-                    # extract the last tile flag and the coordinates (crop and stitch)
-                    last_tile, *stitch_data = self.predictions[batch_idx][1]
-
-                    # append the tile and the coordinates to the lists
-                    self.tiles.append(self.predictions[batch_idx][0])
-                    self.stitching_data.append(stitch_data)
-
-                    # if last tile, stitch the tiles and add array to the prediction
-                    if any(last_tile):
-                        predicted_batches = stitch_prediction(
-                            self.tiles, self.stitching_data
-                        )
-                        self.predicted_array.append(predicted_batches)
-                        self.tiles.clear()
-                        self.stitching_data.clear()
-                else:
-                    # simply add the prediction to the list
-                    self.predicted_array.append(self.predictions[batch_idx])
-                ########################################################
-            except StopIteration:
-                break
-            finally:
-                self._restarting = False
-        return self.on_run_end()
-
-    # TODO predictions aren't stacked, list returned

careamics/losses/noise_model_factory.py

@@ -1,40 +0,0 @@
-from typing import Type, Union
-
-from ..config.noise_models import NoiseModel, NoiseModelType
-from .noise_models import GaussianMixtureNoiseModel, HistogramNoiseModel
-
-
-def noise_model_factory(
-    noise_config: NoiseModel,
-) -> Type[Union[HistogramNoiseModel, GaussianMixtureNoiseModel, None]]:
-    """Create loss model based on Configuration.
-
-    Parameters
-    ----------
-    config : Configuration
-        Configuration.
-
-    Returns
-    -------
-    Noise model
-
-    Raises
-    ------
-    NotImplementedError
-        If the noise model is unknown.
-    """
-    noise_model_type = noise_config.model_type if noise_config else None
-
-    if noise_model_type == NoiseModelType.HIST:
-        return HistogramNoiseModel
-
-    elif noise_model_type == NoiseModelType.GMM:
-        return GaussianMixtureNoiseModel
-
-    elif noise_model_type is None:
-        return None
-
-    else:
-        raise NotImplementedError(
-            f"Noise model {noise_model_type} is not yet supported."
-        )