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

careamics/bioimage/__init__.py

@@ -1,15 +0,0 @@
-"""Provide utilities for exporting models to BioImage model zoo."""
-
-__all__ = [
-    "save_bioimage_model",
-    "import_bioimage_model",
-    "get_default_model_specs",
-    "PYTORCH_STATE_DICT",
-]
-
-from .io import (
-    PYTORCH_STATE_DICT,
-    import_bioimage_model,
-    save_bioimage_model,
-)
-from .rdf import get_default_model_specs

careamics/bioimage/docs/Noise2Void.md

@@ -1,5 +0,0 @@
-## Noise2Void
-Learning Denoising From Single Noisy Images
-
-## Cite Noise2Void
-A. Krull, T.-O. Buchholz and F. Jug, "Noise2Void - Learning Denoising From Single Noisy Images," 2019 IEEE/CVF Conference on Computer Vision and Pattern Recognition  (CVPR), 2019, pp. 2124-2132

careamics/bioimage/docs/__init__.py

@@ -1 +0,0 @@
-"""Default algorithm READMEs for bioimage.io format export."""

careamics/bioimage/io.py

@@ -1,182 +0,0 @@
-"""Export to bioimage.io format."""
-from pathlib import Path
-from typing import Union
-
-import torch
-from bioimageio.core import load_resource_description
-from bioimageio.core.build_spec import build_model
-
-from careamics.config.config import Configuration
-from careamics.utils.context import cwd
-
-PYTORCH_STATE_DICT = "pytorch_state_dict"
-
-
-def save_bioimage_model(
-    path: Union[str, Path],
-    config: Configuration,
-    specs: dict,
-) -> None:
-    """
-    Build bioimage model zip file from model RDF data.
-
-    Parameters
-    ----------
-    path : Union[str, Path]
-        Path to the model zip file.
-    config : Configuration
-        Configuration object.
-    specs : dict
-        Model RDF dict.
-    """
-    workdir = config.working_directory
-
-    # temporary folder
-    temp_folder = Path.home().joinpath(".careamics", "bmz_tmp")
-    temp_folder.mkdir(exist_ok=True, parents=True)
-
-    # change working directory to the temp folder
-    with cwd(temp_folder):
-        # load best checkpoint
-        checkpoint_path = workdir.joinpath(
-            f"{config.experiment_name}_best.pth"
-        ).absolute()
-        checkpoint = torch.load(checkpoint_path, map_location="cpu")
-
-        # save chekpoint entries in separate files
-        weight_path = Path("model_weights.pth")
-        torch.save(checkpoint["model_state_dict"], weight_path)
-
-        optim_path = Path("optim.pth")
-        torch.save(checkpoint["optimizer_state_dict"], optim_path)
-
-        scheduler_path = Path("scheduler.pth")
-        torch.save(checkpoint["scheduler_state_dict"], scheduler_path)
-
-        grad_path = Path("grad.pth")
-        torch.save(checkpoint["grad_scaler_state_dict"], grad_path)
-
-        config_path = Path("config.pth")
-        torch.save(config.model_dump(), config_path)
-
-        # create attachments
-        attachments = [
-            str(optim_path),
-            str(scheduler_path),
-            str(grad_path),
-            str(config_path),
-        ]
-
-        # create requirements file
-        requirements = Path("requirements.txt")
-        with open(requirements, "w") as f:
-            f.write("git+https://github.com/CAREamics/careamics.git")
-
-        algo_config = config.algorithm
-        specs.update(
-            {
-                "weight_type": PYTORCH_STATE_DICT,
-                "weight_uri": str(weight_path),
-                "architecture": "careamics.models.unet.UNet",
-                "pytorch_version": torch.__version__,
-                "model_kwargs": {
-                    "conv_dim": algo_config.get_conv_dim(),
-                    "depth": algo_config.model_parameters.depth,
-                    "num_channels_init": algo_config.model_parameters.num_channels_init,
-                },
-                "dependencies": "pip:" + str(requirements),
-                "attachments": {"files": attachments},
-            }
-        )
-
-        if config.algorithm.is_3D:
-            specs["tags"].append("3D")
-        else:
-            specs["tags"].append("2D")
-
-        # build model zip
-        build_model(
-            output_path=Path(path).absolute(),
-            **specs,
-        )
-
-        # remove temporary files
-        for file in temp_folder.glob("*"):
-            file.unlink()
-
-    # delete temporary folder
-    temp_folder.rmdir()
-
-
-def import_bioimage_model(model_path: Union[str, Path]) -> Path:
-    """
-    Load configuration and weights from a bioimage zip model.
-
-    Parameters
-    ----------
-    model_path : Union[str, Path]
-        Path to the bioimage.io archive.
-
-    Returns
-    -------
-    Path
-        Path to the checkpoint.
-
-    Raises
-    ------
-    ValueError
-        If the model format is invalid.
-    FileNotFoundError
-        If the checkpoint file was not found.
-    """
-    model_path = Path(model_path)
-
-    # check the model extension (should be a zip file).
-    if model_path.suffix != ".zip":
-        raise ValueError("Invalid model format. Expected bioimage model zip file.")
-
-    # load the model
-    rdf = load_resource_description(model_path)
-
-    # create a valid checkpoint file from weights and attached files
-    basedir = model_path.parent.joinpath("rdf_model")
-    basedir.mkdir(exist_ok=True)
-    optim_path = None
-    scheduler_path = None
-    grad_path = None
-    config_path = None
-    weight_path = None
-
-    if rdf.weights.get(PYTORCH_STATE_DICT) is not None:
-        weight_path = rdf.weights.get(PYTORCH_STATE_DICT).source
-
-    for file in rdf.attachments.files:
-        if file.name.endswith("optim.pth"):
-            optim_path = file
-        elif file.name.endswith("scheduler.pth"):
-            scheduler_path = file
-        elif file.name.endswith("grad.pth"):
-            grad_path = file
-        elif file.name.endswith("config.pth"):
-            config_path = file
-
-    if (
-        weight_path is None
-        or optim_path is None
-        or scheduler_path is None
-        or grad_path is None
-        or config_path is None
-    ):
-        raise FileNotFoundError(f"No valid checkpoint file was found in {model_path}.")
-
-    checkpoint = {
-        "model_state_dict": torch.load(weight_path, map_location="cpu"),
-        "optimizer_state_dict": torch.load(optim_path, map_location="cpu"),
-        "scheduler_state_dict": torch.load(scheduler_path, map_location="cpu"),
-        "grad_scaler_state_dict": torch.load(grad_path, map_location="cpu"),
-        "config": torch.load(config_path, map_location="cpu"),
-    }
-    checkpoint_path = basedir.joinpath("checkpoint.pth")
-    torch.save(checkpoint, checkpoint_path)
-
-    return checkpoint_path

careamics/bioimage/rdf.py

@@ -1,105 +0,0 @@
-"""RDF related methods."""
-from pathlib import Path
-
-
-def _get_model_doc(name: str) -> str:
-    """
-    Return markdown documentation path for the provided model.
-
-    Parameters
-    ----------
-    name : str
-        Model's name.
-
-    Returns
-    -------
-    str
-        Path to the model's markdown documentation.
-
-    Raises
-    ------
-    FileNotFoundError
-        If the documentation file was not found.
-    """
-    doc = Path(__file__).parent.joinpath("docs").joinpath(f"{name}.md")
-    if doc.exists():
-        return str(doc.absolute())
-    else:
-        raise FileNotFoundError(f"Documentation for {name} was not found.")
-
-
-def get_default_model_specs(
-    name: str, mean: float, std: float, is_3D: bool = False
-) -> dict:
-    """
-    Return the default bioimage.io specs for the provided model's name.
-
-    Currently only supports `Noise2Void` model.
-
-    Parameters
-    ----------
-    name : str
-        Algorithm's name.
-    mean : float
-        Mean of the dataset.
-    std : float
-        Std of the dataset.
-    is_3D : bool, optional
-        Whether the model is 3D or not, by default False.
-
-    Returns
-    -------
-    dict
-        Model specs compatible with bioimage.io export.
-    """
-    rdf = {
-        "name": "Noise2Void",
-        "description": "Self-supervised denoising.",
-        "license": "BSD-3-Clause",
-        "authors": [
-            {"name": "Alexander Krull"},
-            {"name": "Tim-Oliver Buchholz"},
-            {"name": "Florian Jug"},
-        ],
-        "cite": [
-            {
-                "doi": "10.48550/arXiv.1811.10980",
-                "text": 'A. Krull, T.-O. Buchholz and F. Jug, "Noise2Void - Learning '
-                'Denoising From Single Noisy Images," 2019 IEEE/CVF '
-                "Conference on Computer Vision and Pattern Recognition "
-                "(CVPR), 2019, pp. 2124-2132",
-            }
-        ],
-        # "input_axes": ["bcyx"], <- overriden in save_as_bioimage
-        "preprocessing": [  # for multiple inputs
-            [  # multiple processes per input
-                {
-                    "kwargs": {
-                        "axes": "zyx" if is_3D else "yx",
-                        "mean": [mean],
-                        "mode": "fixed",
-                        "std": [std],
-                    },
-                    "name": "zero_mean_unit_variance",
-                }
-            ]
-        ],
-        # "output_axes": ["bcyx"], <- overriden in save_as_bioimage
-        "postprocessing": [  # for multiple outputs
-            [  # multiple processes per input
-                {
-                    "kwargs": {
-                        "axes": "zyx" if is_3D else "yx",
-                        "gain": [std],
-                        "offset": [mean],
-                    },
-                    "name": "scale_linear",
-                }
-            ]
-        ],
-        "tags": ["unet", "denoising", "Noise2Void", "tensorflow", "napari"],
-    }
-
-    rdf["documentation"] = _get_model_doc(name)
-
-    return rdf

careamics/config/algorithm.py

@@ -1,231 +0,0 @@
-"""Algorithm configuration."""
-from enum import Enum
-from typing import Dict, List
-
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-
-from .config_filter import remove_default_optionals
-
-
-# python 3.11: https://docs.python.org/3/library/enum.html
-class Loss(str, Enum):
-    """
-    Available loss functions.
-
-    Currently supported losses:
-
-        - n2v: Noise2Void loss.
-    """
-
-    N2V = "n2v"
-
-
-class Models(str, Enum):
-    """
-    Available models.
-
-    Currently supported models:
-        - UNet: U-Net model.
-    """
-
-    UNET = "UNet"
-
-
-class MaskingStrategy(str, Enum):
-    """
-    Available masking strategy.
-
-    Currently supported strategies:
-
-    - default: default masking strategy of Noise2Void (uniform sampling of neighbors).
-    - median: median masking strategy of N2V2.
-    """
-
-    DEFAULT = "default"
-    MEDIAN = "median"
-
-
-class ModelParameters(BaseModel):
-    """
-    Deep-learning model parameters.
-
-    The number of filters (base) must be even and minimum 8.
-
-    Attributes
-    ----------
-    depth : int
-        Depth of the model, between 1 and 10 (default 2).
-    num_channels_init : int
-        Number of filters of the first level of the network, should be even
-        and minimum 8 (default 96).
-    """
-
-    model_config = ConfigDict(validate_assignment=True)
-
-    depth: int = Field(default=2, ge=1, le=10)
-    num_channels_init: int = Field(default=32, ge=8)
-
-    # TODO revisit the constraints on num_channels_init
-    @field_validator("num_channels_init")
-    def even(cls, num_channels: int) -> int:
-        """
-        Validate that num_channels_init is even.
-
-        Parameters
-        ----------
-        num_channels : int
-            Number of channels.
-
-        Returns
-        -------
-        int
-            Validated number of channels.
-
-        Raises
-        ------
-        ValueError
-            If the number of channels is odd.
-        """
-        # if odd
-        if num_channels % 2 != 0:
-            raise ValueError(
-                f"Number of channels (init) must be even (got {num_channels})."
-            )
-
-        return num_channels
-
-
-class Algorithm(BaseModel):
-    """
-    Algorithm configuration.
-
-    The minimum algorithm configuration is composed of the following fields:
-        - loss:
-            Loss to use, currently only supports n2v.
-        - model:
-            Model to use, currently only supports UNet.
-        - is_3D:
-            Whether to use a 3D model or not, this should be coherent with the
-            data configuration (axes).
-
-    Other optional fields are:
-        - masking_strategy:
-            Masking strategy to use, currently only supports default masking.
-        - masked_pixel_percentage:
-            Percentage of pixels to be masked in each patch.
-        - roi_size:
-            Size of the region of interest to use in the masking algorithm.
-        - model_parameters:
-            Model parameters, see ModelParameters for more details.
-
-    Attributes
-    ----------
-    loss : List[Losses]
-        List of losses to use, currently only supports n2v.
-    model : Models
-        Model to use, currently only supports UNet.
-    is_3D : bool
-        Whether to use a 3D model or not.
-    masking_strategy : MaskingStrategies
-        Masking strategy to use, currently only supports default masking.
-    masked_pixel_percentage : float
-        Percentage of pixels to be masked in each patch.
-    roi_size : int
-        Size of the region of interest used in the masking scheme.
-    model_parameters : ModelParameters
-        Model parameters, see ModelParameters for more details.
-    """
-
-    # Pydantic class configuration
-    model_config = ConfigDict(
-        use_enum_values=True,
-        protected_namespaces=(),  # allows to use model_* as a field name
-        validate_assignment=True,
-    )
-
-    # Mandatory fields
-    loss: Loss
-    model: Models
-    is_3D: bool
-
-    # Optional fields, define a default value
-    masking_strategy: MaskingStrategy = MaskingStrategy.DEFAULT
-    masked_pixel_percentage: float = Field(default=0.2, ge=0.1, le=20)
-    roi_size: int = Field(default=11, ge=3, le=21)
-    model_parameters: ModelParameters = ModelParameters()
-
-    def get_conv_dim(self) -> int:
-        """
-        Get the convolution layers dimension (2D or 3D).
-
-        Returns
-        -------
-        int
-            Dimension (2 or 3).
-        """
-        return 3 if self.is_3D else 2
-
-    @field_validator("roi_size")
-    def even(cls, roi_size: int) -> int:
-        """
-        Validate that roi_size is odd.
-
-        Parameters
-        ----------
-        roi_size : int
-            Size of the region of interest in the masking scheme.
-
-        Returns
-        -------
-        int
-            Validated size of the region of interest.
-
-        Raises
-        ------
-        ValueError
-            If the size of the region of interest is even.
-        """
-        # if even
-        if roi_size % 2 == 0:
-            raise ValueError(f"ROI size must be odd (got {roi_size}).")
-
-        return roi_size
-
-    def model_dump(
-        self, exclude_optionals: bool = True, *args: List, **kwargs: Dict
-    ) -> Dict:
-        """
-        Override model_dump method.
-
-        The purpose is to ensure export smooth import to yaml. It includes:
-            - remove entries with None value.
-            - remove optional values if they have the default value.
-
-        Parameters
-        ----------
-        exclude_optionals : bool, optional
-            Whether to exclude optional arguments if they are default, by default True.
-        *args : List
-            Positional arguments, unused.
-        **kwargs : Dict
-            Keyword arguments, unused.
-
-        Returns
-        -------
-        Dict
-            Dictionary representation of the model.
-        """
-        dictionary = super().model_dump(exclude_none=True)
-
-        if exclude_optionals is True:
-            # remove optional arguments if they are default
-            defaults = {
-                "masking_strategy": MaskingStrategy.DEFAULT.value,
-                "masked_pixel_percentage": 0.2,
-                "roi_size": 11,
-                "model_parameters": ModelParameters().model_dump(exclude_none=True),
-            }
-
-            remove_default_optionals(dictionary, defaults)
-
-        return dictionary