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

careamics/utils/metrics.py

@@ -112,49 +112,3 @@ def scale_invariant_psnr(
     range_parameter = (np.max(gt) - np.min(gt)) / np.std(gt)
     gt_ = _zero_mean(gt) / np.std(gt)
     return psnr(_zero_mean(gt_), _fix(gt_, pred), range_parameter)
-
-
-class MetricTracker:
-    """
-    Metric tracker class.
-
-    This class is used to track values, sum, count and average of a metric over time.
-
-    Attributes
-    ----------
-    val : int
-        Last value of the metric.
-    avg : torch.Tensor.float
-        Average value of the metric.
-    sum : int
-        Sum of the metric values (times number of values).
-    count : int
-        Number of values.
-    """
-
-    def __init__(self) -> None:
-        """Constructor."""
-        self.reset()
-
-    def reset(self) -> None:
-        """Reset the metric tracker state."""
-        self.val = 0.0
-        self.avg: torch.Tensor.float = 0.0
-        self.sum = 0.0
-        self.count = 0.0
-
-    def update(self, value: int, n: int = 1) -> None:
-        """
-        Update the metric tracker state.
-
-        Parameters
-        ----------
-        value : int
-            Value to update the metric tracker with.
-        n : int
-            Number of values, equals to batch size.
-        """
-        self.val = value
-        self.sum += value * n
-        self.count += n
-        self.avg = self.sum / self.count

careamics/utils/path_utils.py

@@ -0,0 +1,24 @@
+from pathlib import Path
+from typing import Union
+
+
+def check_path_exists(path: Union[str, Path]) -> Path:
+    """Check if a path exists. If not, raise an error.
+
+    Note that it returns `path` as a Path object.
+
+    Parameters
+    ----------
+    path : Union[str, Path]
+        Path to check.
+
+    Returns
+    -------
+    Path
+        Path as a Path object.
+    """
+    path = Path(path)
+    if not path.exists():
+        raise FileNotFoundError(f"Data path {path} is incorrect or does not exist.")
+
+    return path

careamics/utils/ram.py

@@ -0,0 +1,13 @@
+import psutil
+
+
+def get_ram_size() -> int:
+    """
+    Get RAM size in bytes.
+
+    Returns
+    -------
+    int
+        RAM size in mbytes.
+    """
+    return psutil.virtual_memory().total / 1024**2

careamics/utils/receptive_field.py

@@ -0,0 +1,102 @@
+"""Receptive field calculation for computing the tile overlap."""
+
+# Adapted from: https://github.com/frgfm/torch-scan
+
+import math
+import warnings
+from typing import Tuple, Union
+
+from torch import Tensor, nn
+from torch.nn import Module
+from torch.nn.modules.batchnorm import _BatchNorm
+from torch.nn.modules.conv import _ConvNd, _ConvTransposeNd
+from torch.nn.modules.pooling import (
+    _AdaptiveAvgPoolNd,
+    _AdaptiveMaxPoolNd,
+    _AvgPoolNd,
+    _MaxPoolNd,
+)
+
+
+def module_rf(module: Module, inp: Tensor, out: Tensor) -> Tuple[float, float, float]:
+    """Estimate the spatial receptive field of the module.
+
+    Args:
+        module (torch.nn.Module): PyTorch module
+        inp (torch.Tensor): input to the module
+        out (torch.Tensor): output of the module
+    Returns:
+        receptive field
+        effective stride
+        effective padding
+    """
+    if isinstance(
+        module,
+        (
+            nn.Identity,
+            nn.Flatten,
+            nn.ReLU,
+            nn.ELU,
+            nn.LeakyReLU,
+            nn.ReLU6,
+            nn.Tanh,
+            nn.Sigmoid,
+            _BatchNorm,
+            nn.Dropout,
+            nn.Linear,
+        ),
+    ):
+        return 1.0, 1.0, 0.0
+    elif isinstance(module, _ConvTransposeNd):
+        return rf_convtransposend(module, inp, out)
+    elif isinstance(module, (_ConvNd, _MaxPoolNd, _AvgPoolNd)):
+        return rf_aggregnd(module, inp, out)
+    elif isinstance(module, (_AdaptiveMaxPoolNd, _AdaptiveAvgPoolNd)):
+        return rf_adaptive_poolnd(module, inp, out)
+    else:
+        warnings.warn(
+            f"Module type not supported: {module.__class__.__name__}", stacklevel=1
+        )
+        return 1.0, 1.0, 0.0
+
+
+def rf_convtransposend(
+    module: _ConvTransposeNd, _: Tensor, __: Tensor
+) -> Tuple[float, float, float]:
+    k = (
+        module.kernel_size[0]
+        if isinstance(module.kernel_size, tuple)
+        else module.kernel_size
+    )
+    s = module.stride[0] if isinstance(module.stride, tuple) else module.stride
+    return -k, 1.0 / s, 0.0
+
+
+def rf_aggregnd(
+    module: Union[_ConvNd, _MaxPoolNd, _AvgPoolNd], _: Tensor, __: Tensor
+) -> Tuple[float, float, float]:
+    k = (
+        module.kernel_size[0]
+        if isinstance(module.kernel_size, tuple)
+        else module.kernel_size
+    )
+    if hasattr(module, "dilation"):
+        d = (
+            module.dilation[0]
+            if isinstance(module.dilation, tuple)
+            else module.dilation
+        )
+        k = d * (k - 1) + 1
+    s = module.stride[0] if isinstance(module.stride, tuple) else module.stride
+    p = module.padding[0] if isinstance(module.padding, tuple) else module.padding
+    return k, s, p  # type: ignore[return-value]
+
+
+def rf_adaptive_poolnd(
+    _: Union[_AdaptiveMaxPoolNd, _AdaptiveAvgPoolNd], inp: Tensor, out: Tensor
+) -> Tuple[int, int, float]:
+    stride = math.ceil(inp.shape[-1] / out.shape[-1])
+    kernel_size = stride
+    padding = (inp.shape[-1] - kernel_size * stride) / 2
+
+    return kernel_size, stride, padding

careamics/utils/running_stats.py

@@ -0,0 +1,43 @@
+"""Running stats submodule, used in the Zarr dataset."""
+
+# from multiprocessing import Value
+# from typing import Tuple
+
+# import numpy as np
+
+
+# class RunningStats:
+#     """Calculates running mean and std."""
+
+#     def __init__(self) -> None:
+#         self.reset()
+
+#     def reset(self) -> None:
+#         """Reset the running stats."""
+#         self.avg_mean = Value("d", 0)
+#         self.avg_std = Value("d", 0)
+#         self.m2 = Value("d", 0)
+#         self.count = Value("i", 0)
+
+#     def init(self, mean: float, std: float) -> None:
+#         """Initialize running stats."""
+#         with self.avg_mean.get_lock():
+#             self.avg_mean.value += mean
+#         with self.avg_std.get_lock():
+#             self.avg_std.value = std
+
+#     def compute_std(self) -> Tuple[float, float]:
+#         """Compute std."""
+#         if self.count.value >= 2:
+#             self.avg_std.value = np.sqrt(self.m2.value / self.count.value)
+
+#     def update(self, value: float) -> None:
+#         """Update running stats."""
+#         with self.count.get_lock():
+#             self.count.value += 1
+#         delta = value - self.avg_mean.value
+#         with self.avg_mean.get_lock():
+#             self.avg_mean.value += delta / self.count.value
+#         delta2 = value - self.avg_mean.value
+#         with self.m2.get_lock():
+#             self.m2.value += delta * delta2

careamics/utils/torch_utils.py

@@ -3,87 +3,124 @@ Convenience functions using torch.
 
 These functions are used to control certain aspects and behaviours of PyTorch.
 """
-import logging
+import inspect
+from typing import Dict, Union
 
 import torch
 
+from careamics.config.support import SupportedOptimizer, SupportedScheduler
 
-def get_device() -> torch.device:
+from ..utils.logging import get_logger
+
+logger = get_logger(__name__)  # TODO are logger still needed?
+
+
+def filter_parameters(
+    func: type,
+    user_params: dict,
+) -> dict:
+    """
+    Filter parameters according to the function signature.
+
+    Parameters
+    ----------
+    func : type
+        Class object.
+    user_params : Dict
+        User provided parameters.
+
+    Returns
+    -------
+    Dict
+        Parameters matching `func`'s signature.
+    """
+    # Get the list of all default parameters
+    default_params = list(inspect.signature(func).parameters.keys())
+
+    # Filter matching parameters
+    params_to_be_used = set(user_params.keys()) & set(default_params)
+
+    return {key: user_params[key] for key in params_to_be_used}
+
+
+def get_optimizer(name: str) -> torch.optim.Optimizer:
+    """
+    Return the optimizer class given its name.
+
+    Parameters
+    ----------
+    name : str
+        Optimizer name.
+
+    Returns
+    -------
+    torch.nn.Optimizer
+        Optimizer class.
+    """
+    if name not in SupportedOptimizer:
+        raise NotImplementedError(f"Optimizer {name} is not yet supported.")
+
+    return getattr(torch.optim, name)
+
+
+def get_optimizers() -> Dict[str, str]:
+    """
+    Return the list of all optimizers available in torch.optim.
+
+    Returns
+    -------
+    Dict
+        Optimizers available in torch.optim.
+    """
+    optims = {}
+    for name, obj in inspect.getmembers(torch.optim):
+        if inspect.isclass(obj) and issubclass(obj, torch.optim.Optimizer):
+            if name != "Optimizer":
+                optims[name] = name
+    return optims
+
+
+def get_scheduler(
+    name: str,
+) -> Union[
+    torch.optim.lr_scheduler.LRScheduler,
+    torch.optim.lr_scheduler.ReduceLROnPlateau,
+]:
+    """
+    Return the scheduler class given its name.
+
+    Parameters
+    ----------
+    name : str
+        Scheduler name.
+
+    Returns
+    -------
+    Union
+        Scheduler class.
+    """
+    if name not in SupportedScheduler:
+        raise NotImplementedError(f"Scheduler {name} is not yet supported.")
+
+    return getattr(torch.optim.lr_scheduler, name)
+
+
+def get_schedulers() -> Dict[str, str]:
     """
-    Select the device to use for training.
+    Return the list of all schedulers available in torch.optim.lr_scheduler.
 
     Returns
     -------
-    torch.device
-        CUDA or CPU device, depending on availability of CUDA devices.
+    Dict
+        Schedulers available in torch.optim.lr_scheduler.
     """
-    if torch.cuda.is_available():
-        logging.info("CUDA available. Using GPU.")
-        device = torch.device("cuda")
-    else:
-        logging.info("CUDA not available. Using CPU.")
-        device = torch.device("cpu")
-    return device
-
-
-# def compile_model(model: torch.nn.Module) -> torch.nn.Module:
-#     """
-#     Torch.compile wrapper.
-
-#     Parameters
-#     ----------
-#     model : torch.nn.Module
-#         Model.
-
-#     Returns
-#     -------
-#     torch.nn.Module
-#         Compiled model if compile is available, the model itself otherwise.
-#     """
-#     if hasattr(torch, "compile") and sys.version_info.minor <= 9:
-#         return torch.compile(model, mode="reduce-overhead")
-#     else:
-#         return model
-
-
-# def seed_everything(seed: int) -> None:
-#     """
-#     Seed all random number generators for reproducibility.
-
-#     Parameters
-#     ----------
-#     seed : int
-#         Seed.
-#     """
-#     import random
-
-#     import numpy as np
-
-#     random.seed(seed)
-#     np.random.seed(seed)
-#     torch.manual_seed(seed)
-#     torch.cuda.manual_seed_all(seed)
-
-
-# def setup_cudnn_reproducibility(
-#     deterministic: bool = True, benchmark: bool = True
-# ) -> None:
-#     """
-#     Prepare CuDNN benchmark and sets it to be deterministic/non-deterministic mode.
-
-#     Parameters
-#     ----------
-#     deterministic : bool
-#         Deterministic mode, if running CuDNN backend.
-#     benchmark : bool
-#         If True, uses CuDNN heuristics to figure out which algorithm will be most
-#         performant for your model architecture and input. False may slow down training
-#     """
-#     if torch.cuda.is_available():
-#         if deterministic:
-#             deterministic = os.environ.get("CUDNN_DETERMINISTIC", "True") == "True"
-#         torch.backends.cudnn.deterministic = deterministic
-
-#         if benchmark:
-#             benchmark = os.environ.get("CUDNN_BENCHMARK", "True") == "True"
-#         torch.backends.cudnn.benchmark = benchmark
+    schedulers = {}
+    for name, obj in inspect.getmembers(torch.optim.lr_scheduler):
+        if inspect.isclass(obj) and issubclass(
+            obj, torch.optim.lr_scheduler.LRScheduler
+        ):
+            if "LRScheduler" not in name:
+                schedulers[name] = name
+        elif name == "ReduceLROnPlateau":  # somewhat not a subclass of LRScheduler
+            schedulers[name] = name
+    return schedulers

careamics-0.1.0rc3.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.3
+Name: careamics
+Version: 0.1.0rc3
+Summary: Toolbox for running N2V and friends.
+Project-URL: homepage, https://careamics.github.io/
+Project-URL: repository, https://github.com/CAREamics/careamics
+Author-email: Igor Zubarev <igor.zubarev@fht.org>, Joran Deschamps <joran.deschamps@fht.org>
+License: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+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
+Requires-Dist: pytorch-lightning>=2.2.0
+Requires-Dist: pyyaml
+Requires-Dist: scikit-image
+Requires-Dist: tifffile
+Requires-Dist: torch>=2.0.0
+Requires-Dist: zarr
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: sybil; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: careamics-portfolio; extra == 'examples'
+Requires-Dist: jupyter; extra == 'examples'
+Requires-Dist: matplotlib; extra == 'examples'
+Provides-Extra: tensorboard
+Requires-Dist: protobuf==3.20.3; extra == 'tensorboard'
+Requires-Dist: tensorboard; extra == 'tensorboard'
+Provides-Extra: wandb
+Requires-Dist: wandb; extra == 'wandb'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://careamics.github.io/">
+    <img src="https://raw.githubusercontent.com/CAREamics/.github/main/profile/images/banner_careamics.png">
+  </a>
+</p>
+
+# CAREamics Restoration
+
+[![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)
+[![Python Version](https://img.shields.io/pypi/pyversions/careamics.svg?color=green)](https://python.org)
+[![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/).
+
+## Usage
+
+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
+
+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
+
+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).
+

careamics-0.1.0rc3.dist-info/RECORD

@@ -0,0 +1,109 @@
+careamics/__init__.py,sha256=7Zfey0kcF5eSouzc0I1bnGg77wys7NyRy61s9BCU3Xs,676
+careamics/careamist.py,sha256=44JhiyRsuPH_rmfoIdECpolp8bXnFBv3CUCm8pBb0zU,28336
+careamics/conftest.py,sha256=WR_iw4Eebfq6r_sY1No4GfB-_XG5JMkpxXpoorWy8Eg,658
+careamics/lightning_datamodule.py,sha256=MA6qwvCAf-Umz8fwJJgGEsXX76yVa_8BFEo4nsMBYuQ,28552
+careamics/lightning_module.py,sha256=nxReAzoWBZZy2E8JMsef72hIC_4WTh0kvvVf5sgpcYM,10159
+careamics/lightning_prediction_datamodule.py,sha256=yzJcfvhlN8k6ylOrTO-Y_NLSeQNTHklqhhjFxffLyiA,15053
+careamics/lightning_prediction_loop.py,sha256=EcUSgM2BHkWhjR4zN0NNf2M8xQF_I3aQ9qAFk0slYYw,4483
+careamics/py.typed,sha256=esB4cHc6c07uVkGtqf8at7ttEnprwRxwk8obY8Qumq4,187
+careamics/callbacks/__init__.py,sha256=spxJlDByD-6QtMl9vcIty8Wb0tyHaSTKTItozHenI44,204
+careamics/callbacks/hyperparameters_callback.py,sha256=CdOtxazXi6YXH3Fq4AahqBQ3Ai64YpAMkd8gFnAnkjc,1258
+careamics/callbacks/progress_bar_callback.py,sha256=ojeat3wwaqq7uEAVZBren71CZtNiEch1FR7o8FiaEPg,1868
+careamics/config/__init__.py,sha256=V8oV-QxJAGtjZRcyMIeSPqONJvzXroRB_-pA_uDEr70,886
+careamics/config/algorithm_model.py,sha256=sBUX80tdnzlvdUYlPJ9m4dUAL8GKu22BcrUfZT6jQoE,5727
+careamics/config/callback_model.py,sha256=h4q5tbjpauL5gQ1joeRvJw8Bes1s7Lp2dvcoHnFozqY,3225
+careamics/config/configuration_factory.py,sha256=AeqVtnj-lAwkhNS-SatU4naoN-Oy2ewBpq8e0FM443k,14610
+careamics/config/configuration_model.py,sha256=KK7r_JIgGt07CoK-HCrS-sb2wHMC6M9zLZ9OeVLNGc0,18730
+careamics/config/data_model.py,sha256=hPdpX08B2_woGRnwKU6IQtUbTQ_br5upNsAPjbbkX-g,16806
+careamics/config/inference_model.py,sha256=-iLrXlJbjFaCoy9jX1YDb2Afvl7xRj3rSeTt-oblzSE,8126
+careamics/config/noise_models.py,sha256=1P6dXqqBhbVHT7EZ2hluO2aHKIywkAyl4BndrvtKRKU,4338
+careamics/config/optimizer_models.py,sha256=Umu6O2qKv1o4ReWBuldAHmvF0u_DKS5eHCa7YdxvOaw,5266
+careamics/config/tile_information.py,sha256=2bVLTvZfdjPOZVq7jYXVuAFLlPFmJ2DBiwtwm5n7K-U,2939
+careamics/config/training_model.py,sha256=T0E0uu_u7dVQg5rZIynD-JhCVbKKzFO7EP-CboiFLsU,1557
+careamics/config/architectures/__init__.py,sha256=CdnViydyTdQixus3uWHBIgbgxmu9t1_ADehqpjN_57U,444
+careamics/config/architectures/architecture_model.py,sha256=EomNAhjuhu3uqEjzG6uvRclSQNVuGkcH_mt4R47yIHg,681
+careamics/config/architectures/custom_model.py,sha256=2tMvr6XqFY8hY8Tfljba-kp1c61fDKaV4vylbg4AyUg,4473
+careamics/config/architectures/register_model.py,sha256=sW6fvj54F6G1rg3fmXTwCAu_YcKs3xZTsdYnDGFRahY,2389
+careamics/config/architectures/unet_model.py,sha256=8zV9W1x9lvSCWNgtXmnPMBqt7s_-AzsUex9sjjNTe9c,2788
+careamics/config/architectures/vae_model.py,sha256=n1pvVmpelNqQXsXtxXPdmMBBkCLyMIlTQJbMqB-amCc,899
+careamics/config/references/__init__.py,sha256=rZAQzmrciX5cNICcXaBH6sbE6N6L7_qYQUkasNy9y-c,763
+careamics/config/references/algorithm_descriptions.py,sha256=LzY66zAtKj9705omjfhV0Ziq7vhWSZ4Tq_GPDwE2P-E,3540
+careamics/config/references/references.py,sha256=vcbt9qfsdzOmzqizu8COjtIXlrAyH6UT6bgoJy8D5oo,1572
+careamics/config/support/__init__.py,sha256=XMnPEPHVy63DDxAfczIFqFjuYrtDRrbzA5b0Ff1qmyU,1149
+careamics/config/support/supported_activations.py,sha256=-KaTxdm8IJ9c6xkCVMw3SWjbw6wmvV-1WuoeSbyCdH4,476
+careamics/config/support/supported_algorithms.py,sha256=wc3pTYhgoZ0W_O6jcJY0ZsVErYMSTmi24ptw3ezAuUw,316
+careamics/config/support/supported_architectures.py,sha256=EDrh8eghqxWcwjXVhhJpfymV6dsmyaUxk2E397VXXbA,495
+careamics/config/support/supported_data.py,sha256=AvdoWVLLpX5jzozJGUqeo5EJVkb6Z_OcQbaS8AkyHSg,2048
+careamics/config/support/supported_extraction_strategies.py,sha256=oVSVbFBrVMvvtHGtK5_e306ef3splJZHialoSQM_0zs,578
+careamics/config/support/supported_loggers.py,sha256=slbpUZSMdRMCKNAQfnCxh7n1Sql2NFoH79cIoiuavcU,159
+careamics/config/support/supported_losses.py,sha256=fu0SPPhubMVq3zXJk8G8Av9ojWNw62EKm7WnUmapuRs,502
+careamics/config/support/supported_optimizers.py,sha256=iUjxE6Yh3KV6u42kfXDe83pt8MbFaS-rm1OO7zwFLf8,1333
+careamics/config/support/supported_pixel_manipulations.py,sha256=0lZfCwL9bwPK5E8qzi7l9UGOq41U2fCH9KpxnDEpznc,360
+careamics/config/support/supported_struct_axis.py,sha256=VzyKEVwNARtF9HviAmsHqAjyenHCRFR5UObks6s6R9Y,378
+careamics/config/support/supported_transforms.py,sha256=7lF2ZdWC7Fa7ExemQ6JzM9s9RXM0_tsGWilmmq-MoMw,889
+careamics/config/transformations/__init__.py,sha256=FnLBxNyJ0cTPf8e1dhtkhks5vu_z8Wi48aBjvAPDErk,357
+careamics/config/transformations/n2v_manipulate_model.py,sha256=OjZ2GK02BhNPR2U1wXSUE71p-zwn6Y6PERLk_2tR0og,1835
+careamics/config/transformations/nd_flip_model.py,sha256=7ah1Dxav_BKShH3MO1Nh7QQ5dNwGq4wqXwrEtZHvWCM,845
+careamics/config/transformations/normalize_model.py,sha256=zl7yCfaEzF0G19L7BLPT3Ke0t9y5aXQOqWTc3doIIGo,789
+careamics/config/transformations/transform_model.py,sha256=HqCnZLr-K9d54CxK8M0UaXdPqnPYso5Wg1i2dK5dmBI,999
+careamics/config/transformations/xy_random_rotate90_model.py,sha256=U0kIPWI4XU7KrDuVfyCHqq28TEqdp-KcHQDXuaH4uw8,775
+careamics/config/validators/__init__.py,sha256=iv0nVI0W7j9DxFPwh0DjRCzM9P8oLQn4Gwi5rfuFrrI,180
+careamics/config/validators/validator_utils.py,sha256=81t79useG0ZfwZdodLfSl_799hBMriiFrohStRHl9nc,2623
+careamics/dataset/__init__.py,sha256=cUcqy1Nxa5WhDQim6948r3i1kGQ-HijUqAACyyM7cuU,174
+careamics/dataset/in_memory_dataset.py,sha256=5qoMpHOw-9Fhb3y6QTHGvIALCd-uvxgctREFF6WT79U,12209
+careamics/dataset/iterable_dataset.py,sha256=P4-yjZYAA_baw2_tjcr5F2FskHjAEYCneyoVBflx9dY,15030
+careamics/dataset/zarr_dataset.py,sha256=cpouzhaWUOkqAjjliJhrtfqVvZEMaq1d9V3LDoEvJQA,5644
+careamics/dataset/dataset_utils/__init__.py,sha256=nt3IzCFa8JstXbheNrA5D_wlJe0PNFpABmBA3f_Jsj0,447
+careamics/dataset/dataset_utils/dataset_utils.py,sha256=bKAUvLrnS-zxCpJ7H56clJ2pGB3jYYh7F20ZkG7bDIQ,2666
+careamics/dataset/dataset_utils/file_utils.py,sha256=VHK7__34keJfkYWfyrOApalFA0wyINLK7CB79T_Sqm4,4030
+careamics/dataset/dataset_utils/read_tiff.py,sha256=KcO5pZXaXEGXlJoCLnFriAHmHACCPI5kRWZK-oovfBo,1648
+careamics/dataset/dataset_utils/read_utils.py,sha256=hwb2pFr-ueusVf8hoTtDsD71V5HDVU-6eQ14cpPp6d4,547
+careamics/dataset/dataset_utils/read_zarr.py,sha256=B75gaOsLctkonYqwouCDWBu-AVwy697mJbEXDC0ft3I,1635
+careamics/dataset/patching/__init__.py,sha256=UJBR4X1H5B6BIcayesPGpWjxTkub1alf9Uzj_5mdnFE,130
+careamics/dataset/patching/patch_transform.py,sha256=kgUNUuk5QbJ8sZ3CFmBq06kO0FuclICX97Sj4PqoxyQ,1375
+careamics/dataset/patching/patching.py,sha256=aQbjJLa56x22WALV31K0SFvxFNtTZ-FX9EP1RiqTt0k,6258
+careamics/dataset/patching/random_patching.py,sha256=93R5a56O4k6CxrWvRpTwkFDnw37tpDTaajcPAQbc4Nw,6025
+careamics/dataset/patching/sequential_patching.py,sha256=Vm6em2ZPVUzqmrwLWJwD4jhI8hcSMjZ6YzpX7_nLUB8,5688
+careamics/dataset/patching/tiled_patching.py,sha256=Kq0CENa8JNINMMTGySmCdYjBPieFQKgxa14WbntPbtk,5702
+careamics/dataset/patching/validate_patch_dimension.py,sha256=cHiD2XNX44eArlRR7ZK7_4Mihv3DzjncthgN-nXqR4s,2001
+careamics/losses/__init__.py,sha256=tpiq1pGabqGm8U0AxfMM5bUkgXVCwG_8vzyVf_XeEVU,216
+careamics/losses/loss_factory.py,sha256=2gx5QkwLT79FlKpIj_-IZMoiH6VnzJ2KTo2Iy_cBwgI,991
+careamics/losses/losses.py,sha256=a-8NLw0R86r2XxcHh97D7Mnhtbn0c5VFjZLPfttKCCM,2304
+careamics/losses/noise_model_factory.py,sha256=zbRxlU3hTLJR9fM-PkeTthQ8idrwJD7-AelvXxaoHEQ,988
+careamics/losses/noise_models.py,sha256=fRr4_mxP_jirC-UkQDVF09RcwqvZJES9JVCc8tccCFc,17801
+careamics/model_io/__init__.py,sha256=x_wtgBZWoLWFLyrKmYFfc6rP-nLiRsBTqPBed3sT1Vo,156
+careamics/model_io/bmz_io.py,sha256=aWA5vM_tbxxcaE0OSjDugEF8O9d7n6i5Gf-gL4NnhxA,6943
+careamics/model_io/model_io_utils.py,sha256=0XHIhpzeY_8IkWlG_eto_x3IQ5z6y9hI3iUJ7l7ylH0,2108
+careamics/model_io/bioimage/__init__.py,sha256=r94nu8WDAvj0Fbu4C-iJXdOhfSQXeZBvN3UKsLG0RNI,298
+careamics/model_io/bioimage/_readme_factory.py,sha256=cXNu2ZZdlSM7sfYo16wKSfS8CDoBsvNBj96k0HSk8vw,3498
+careamics/model_io/bioimage/bioimage_utils.py,sha256=YOaiaxFOvJYtrUZt9m447wgQr4nwZTcayVrqPbEopYg,1084
+careamics/model_io/bioimage/model_description.py,sha256=AE0SPt3D0o5M0kGjqMNjWQ0X4vlWOOi0uYrC9jMOHQ8,9204
+careamics/models/__init__.py,sha256=Wty5hwQb_As33pQOZqY5j-DpDOdh5ArBH4BhQDSuXTQ,133
+careamics/models/activation.py,sha256=21g0isrf_SpY4MUQoxbcsc1hAP5luSmWgtzGOvXKzTw,936
+careamics/models/layers.py,sha256=3KBGhOgiZH-vz-fzvmHcFjCSUypi8ttNh2KDIWmx3Tg,11557
+careamics/models/model_factory.py,sha256=8jJHfY5tCkosmlfIaYy7DtMNW8wRJ0Ur2g54N1vjitY,1358
+careamics/models/unet.py,sha256=E5zRIRpVv7CeMcMddmHGL5UCBm_DCnVR323UXNkjZT4,10925
+careamics/prediction/__init__.py,sha256=-Bfc7UqPSqpGx0NGvHMkE-bHOkZYMn7EaxQ9tO6A3uU,118
+careamics/prediction/stitch_prediction.py,sha256=IPTTJ8FA0j_vmUOfqiiLe3JF6v5NlSOD3fBL1ZTQkq0,2215
+careamics/transforms/__init__.py,sha256=SRquA3XotroxiUF-AbUUkSeGVuX_BM8cauZplCwQqg4,1093
+careamics/transforms/n2v_manipulate.py,sha256=c16grua6w33ZRVVfW7wAOJ6EyvgPt0cXprTgBLSpKOg,4191
+careamics/transforms/nd_flip.py,sha256=NY0y2lrkF98XUE_twnPQ9z2xSxMvV2bYeVrJKKemjUU,2827
+careamics/transforms/normalize.py,sha256=khmL2xKNWHEWVx2oJWH-_JCDv9d5krFJgBQtuufaYT4,2727
+careamics/transforms/pixel_manipulation.py,sha256=FfTM7V2ql0vqRSFUsebBuIIPjcLo_rW8j74Lo2cUVaA,12776
+careamics/transforms/struct_mask_parameters.py,sha256=tcxs_MHxZTD6PZE2q5gsGJYIMDF368X9Ggw8O9SkfP0,360
+careamics/transforms/tta.py,sha256=4RqHwlOPpBDlHnv68XX_55ggxc2FHiepxRXIH1BfX30,1982
+careamics/transforms/xy_random_rotate90.py,sha256=hvXrpgK-rb4l7quRX6kXeostWr6cS-l0CicRzX2xcac,2710
+careamics/utils/__init__.py,sha256=vvrTq-DSqVwqrVlEDEgKygeN90ztn0aBKOcF88_t_Lo,335
+careamics/utils/base_enum.py,sha256=eoMYdKpcEojJWXrIxzchY1U0W_AubLijMt27WMoSXoc,753
+careamics/utils/context.py,sha256=S_c7PTNohilmnUVgWcKO1afVArHByKvJ2xTpAcXSUvs,1408
+careamics/utils/logging.py,sha256=VP6QK4GqVGZiVCOHcFwrfOY6qrvMvqP6_Wj2sZpbvfc,10321
+careamics/utils/metrics.py,sha256=nlZsewTQLTmmhvIHyio8lCDjXLkXSnWTEgzvqsBb64Q,2381
+careamics/utils/path_utils.py,sha256=mYxqHxHNKLKPJrs4w7ncyvUsoDVRRZZCVl_SJLW0tRs,518
+careamics/utils/ram.py,sha256=kI637_OtrOF0SoHfp_EcyszhlCwtufv1q4M-p0XUqgA,198
+careamics/utils/receptive_field.py,sha256=uALb2oCh4C_xmejdOU2aqyo5fOO9W2713Xb8QGQZvaw,3027
+careamics/utils/running_stats.py,sha256=GIPMPuH9EOUKD_cYBkJFPggXRKnQEiOXx68Pq9UCCVI,1384
+careamics/utils/torch_utils.py,sha256=gPZvuiWDoq8DwQZ3sddM9td8-WAlbOOm8dwspqHe27I,3013
+careamics-0.1.0rc3.dist-info/METADATA,sha256=dUyjgINtvSuWkPJalDPURT65eYcVMJQedEcyB_41TQU,4631
+careamics-0.1.0rc3.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+careamics-0.1.0rc3.dist-info/licenses/LICENSE,sha256=6zdNW-k_xHRKYWUf9tDI_ZplUciFHyj0g16DYuZ2udw,1509
+careamics-0.1.0rc3.dist-info/RECORD,,

{careamics-0.1.0rc2.dist-info → careamics-0.1.0rc3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.0
+Generator: hatchling 1.24.2
 Root-Is-Purelib: true
 Tag: py3-none-any