spacr 0.5.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

spacr/resources/MEDIAR/main.py

@@ -1,125 +0,0 @@
-import torch
-import os
-import wandb
-import argparse, pprint
-
-from train_tools import *
-from SetupDict import TRAINER, OPTIMIZER, SCHEDULER, MODELS, PREDICTOR
-
-# Ignore warnings for tiffle image reading
-import logging
-
-logging.getLogger().setLevel(logging.ERROR)
-
-# Set torch base print precision
-torch.set_printoptions(6)
-
-
-def _get_setups(args):
-    """Get experiment configuration"""
-
-    # Set model
-    model_args = args.train_setups.model
-    model = MODELS[model_args.name](**model_args.params)
-
-    # Load pretrained weights
-    if model_args.pretrained.enabled:
-        weights = torch.load(model_args.pretrained.weights, map_location="cpu")
-
-        print("\nLoading pretrained model....")
-        model.load_state_dict(weights, strict=model_args.pretrained.strict)
-
-    # Set dataloaders
-    dataloaders = datasetter.get_dataloaders_labeled(**args.data_setups.labeled)
-
-    # Set optimizer
-    optimizer_args = args.train_setups.optimizer
-    optimizer = OPTIMIZER[optimizer_args.name](
-        model.parameters(), **optimizer_args.params
-    )
-
-    # Set scheduler
-    scheduler = None
-
-    if args.train_setups.scheduler.enabled:
-        scheduler_args = args.train_setups.scheduler
-        scheduler = SCHEDULER[scheduler_args.name](optimizer, **scheduler_args.params)
-
-    # Set trainer
-    trainer_args = args.train_setups.trainer
-    trainer = TRAINER[trainer_args.name](
-        model, dataloaders, optimizer, scheduler, **trainer_args.params
-    )
-
-    # Check if no validation
-    if args.data_setups.labeled.valid_portion == 0:
-        trainer.no_valid = True
-
-    # Set public dataloader
-    if args.data_setups.public.enabled:
-        dataloaders = datasetter.get_dataloaders_public(
-            **args.data_setups.public.params
-        )
-        trainer.public_loader = dataloaders["public"]
-        trainer.public_iterator = iter(dataloaders["public"])
-
-    return trainer
-
-
-def main(args):
-    """Execute experiment."""
-
-    # Initialize W&B
-    wandb.init(config=args, **args.wandb_setups)
-
-    # How many batches to wait before logging training status
-    wandb.config.log_interval = 10
-
-    # Fix randomness for reproducibility
-    random_seeder(args.train_setups.seed)
-
-    # Set experiment
-    trainer = _get_setups(args)
-
-    # Watch parameters & gradients of model
-    wandb.watch(trainer.model, log="all", log_graph=True)
-
-    # Conduct experiment
-    trainer.train()
-
-    # Upload model to wandb server
-    model_path = os.path.join(wandb.run.dir, "model.pth")
-    torch.save(trainer.model.state_dict(), model_path)
-    wandb.save(model_path)
-
-    # Conduct prediction using the trained model
-    predictor = PREDICTOR[args.train_setups.trainer.name](
-        trainer.model,
-        args.train_setups.trainer.params.device,
-        args.pred_setups.input_path,
-        args.pred_setups.output_path,
-        args.pred_setups.make_submission,
-        args.pred_setups.exp_name,
-        args.pred_setups.algo_params,
-    )
-
-    total_time = predictor.conduct_prediction()
-    wandb.log({"total_time": total_time})
-
-
-# Parser arguments for terminal execution
-parser = argparse.ArgumentParser(description="Config file processing")
-parser.add_argument("--config_path", default="./config/baseline.json", type=str)
-args = parser.parse_args()
-
-#######################################################################################
-
-if __name__ == "__main__":
-    # Load configuration from .json file
-    opt = ConfLoader(args.config_path).opt
-
-    # Print configuration dictionary pretty
-    pprint_config(opt)
-
-    # Run experiment
-    main(opt)

spacr/resources/MEDIAR/predict.py

@@ -1,70 +0,0 @@
-import torch
-import argparse, pprint
-
-from train_tools import *
-from SetupDict import MODELS, PREDICTOR
-
-# Set torch base print precision
-torch.set_printoptions(6)
-
-
-def main(args):
-    """Execute prediction and save the results"""
-
-    model_args = args.pred_setups.model
-    model = MODELS[model_args.name](**model_args.params)
-
-    if "ensemble" in args.pred_setups.name:
-        weights = torch.load(args.pred_setups.model_path1, map_location="cpu")
-        model.load_state_dict(weights, strict=False)
-
-        model_aux = MODELS[model_args.name](**model_args.params)
-        weights_aux = torch.load(args.pred_setups.model_path2, map_location="cpu")
-        model_aux.load_state_dict(weights_aux, strict=False)
-
-        predictor = PREDICTOR[args.pred_setups.name](
-            model,
-            model_aux,
-            args.pred_setups.device,
-            args.pred_setups.input_path,
-            args.pred_setups.output_path,
-            args.pred_setups.make_submission,
-            args.pred_setups.exp_name,
-            args.pred_setups.algo_params,
-        )
-
-    else:
-        weights = torch.load(args.pred_setups.model_path, map_location="cpu")
-        model.load_state_dict(weights, strict=False)
-
-        predictor = PREDICTOR[args.pred_setups.name](
-            model,
-            args.pred_setups.device,
-            args.pred_setups.input_path,
-            args.pred_setups.output_path,
-            args.pred_setups.make_submission,
-            args.pred_setups.exp_name,
-            args.pred_setups.algo_params,
-        )
-
-    _ = predictor.conduct_prediction()
-
-
-# Parser arguments for terminal execution
-parser = argparse.ArgumentParser(description="Config file processing")
-parser.add_argument(
-    "--config_path", default="./config/step3_prediction/base_prediction.json", type=str
-)
-args = parser.parse_args()
-
-#######################################################################################
-
-if __name__ == "__main__":
-    # Load configuration from .json file
-    opt = ConfLoader(args.config_path).opt
-
-   # Print configuration dictionary pretty
-    pprint_config(opt)
-
-    # Run experiment
-    main(opt)

spacr/resources/MEDIAR/requirements.txt

@@ -1,14 +0,0 @@
-fastremap==1.14.1
-monai==1.3.0
-numba==0.57.1
-numpy==1.24.3
-pandas==2.0.3
-pytz==2023.3.post1
-scipy==1.12.0
-segmentation_models_pytorch==0.3.3
-tifffile==2023.4.12
-torch==2.1.2
-tqdm==4.65.0
-wandb==0.16.2
-scikit-image
-matplotlib

spacr/resources/MEDIAR/train_tools/__init__.py

@@ -1,3 +0,0 @@
-from .data_utils import *
-from .measures import *
-from .utils import *

spacr/resources/MEDIAR/train_tools/data_utils/__init__.py

@@ -1 +0,0 @@
-from .datasetter import *

spacr/resources/MEDIAR/train_tools/data_utils/custom/CellAware.py

@@ -1,88 +0,0 @@
-import numpy as np
-import copy
-
-from monai.transforms import RandScaleIntensity, Compose
-from monai.transforms.compose import MapTransform
-from skimage.segmentation import find_boundaries
-
-
-__all__ = ["BoundaryExclusion", "IntensityDiversification"]
-
-
-class BoundaryExclusion(MapTransform):
-    """Map the cell boundary pixel labels to the background class (0)."""
-
-    def __init__(self, keys=["label"], allow_missing_keys=False):
-        super(BoundaryExclusion, self).__init__(keys, allow_missing_keys)
-
-    def __call__(self, data):
-        # Find and Exclude Boundary
-        label_original = data["label"]
-        label = copy.deepcopy(label_original)
-        boundary = find_boundaries(label, connectivity=1, mode="thick")
-        label[boundary] = 0
-
-        # Do not exclude if the cell is too small (< 14x14).
-        new_label = copy.deepcopy(label_original)
-        new_label[label == 0] = 0
-
-        cell_idx, cell_counts = np.unique(label_original, return_counts=True)
-
-        for k in range(len(cell_counts)):
-            if cell_counts[k] < 196:
-                new_label[label_original == cell_idx[k]] = cell_idx[k]
-
-        # Do not exclude if the pixels are at the image boundaries.
-        _, W, H = label_original.shape
-        bd = np.zeros_like(label_original, dtype=label.dtype)
-        bd[:, 2 : W - 2, 2 : H - 2] = 1
-        new_label += label_original * bd
-
-        # Assign the transformed label
-        data["label"] = new_label
-
-        return data
-
-
-class IntensityDiversification(MapTransform):
-    """Randomly rescale the intensity of cell pixels."""
-
-    def __init__(
-        self,
-        keys=["img"],
-        change_cell_ratio=0.4,
-        scale_factors=[0, 0.7],
-        allow_missing_keys=False,
-    ):
-        super(IntensityDiversification, self).__init__(keys, allow_missing_keys)
-
-        self.change_cell_ratio = change_cell_ratio
-        self.randscale_intensity = Compose(
-            [RandScaleIntensity(prob=1.0, factors=scale_factors)]
-        )
-
-    def __call__(self, data):
-        # Select cells to be transformed
-        cell_count = int(data["label"].max())
-        change_cell_count = int(cell_count * self.change_cell_ratio)
-        change_cell = np.random.choice(cell_count, change_cell_count, replace=False)
-
-        mask = copy.deepcopy(data["label"])
-
-        for i in range(cell_count):
-            cell_id = i + 1
-
-            if cell_id not in change_cell:
-                mask[mask == cell_id] = 0
-
-        mask[mask > 0] = 1
-
-        # Conduct intensity transformation for the selected cells
-        img_original = copy.deepcopy((1 - mask) * data["img"])
-        img_transformed = copy.deepcopy(mask * data["img"])
-        img_transformed = self.randscale_intensity(img_transformed)
-
-        # Assign the transformed image
-        data["img"] = img_original + img_transformed
-
-        return data

spacr/resources/MEDIAR/train_tools/data_utils/custom/LoadImage.py

@@ -1,161 +0,0 @@
-import numpy as np
-import tifffile as tif
-import skimage.io as io
-from typing import Optional, Sequence, Union
-from monai.config import DtypeLike, PathLike, KeysCollection
-from monai.utils import ensure_tuple
-from monai.data.utils import is_supported_format, optional_import, ensure_tuple_rep
-from monai.data.image_reader import ImageReader, NumpyReader
-from monai.transforms import LoadImage, LoadImaged
-from monai.utils.enums import PostFix
-
-DEFAULT_POST_FIX = PostFix.meta()
-itk, has_itk = optional_import("itk", allow_namespace_pkg=True)
-
-__all__ = [
-    "CustomLoadImaged",
-    "CustomLoadImageD",
-    "CustomLoadImageDict",
-    "CustomLoadImage",
-]
-
-
-class CustomLoadImage(LoadImage):
-    """
-    Load image file or files from provided path based on reader.
-    If reader is not specified, this class automatically chooses readers
-    based on the supported suffixes and in the following order:
-
-        - User-specified reader at runtime when calling this loader.
-        - User-specified reader in the constructor of `LoadImage`.
-        - Readers from the last to the first in the registered list.
-        - Current default readers: (nii, nii.gz -> NibabelReader), (png, jpg, bmp -> PILReader),
-          (npz, npy -> NumpyReader), (nrrd -> NrrdReader), (DICOM file -> ITKReader).
-
-    [!Caution] This overriding replaces the original ITK with Custom UnifiedITKReader.
-    """
-
-    def __init__(
-        self,
-        reader=None,
-        image_only: bool = False,
-        dtype: DtypeLike = np.float32,
-        ensure_channel_first: bool = False,
-        *args,
-        **kwargs,
-    ) -> None:
-        super(CustomLoadImage, self).__init__(
-            reader, image_only, dtype, ensure_channel_first, *args, **kwargs
-        )
-
-        # Adding TIFFReader. Although ITK Reader supports ".tiff" files, sometimes fails to load images.
-        self.readers = []
-        self.register(UnifiedITKReader(*args, **kwargs))
-
-
-class CustomLoadImaged(LoadImaged):
-    """
-    Dictionary-based wrapper of `CustomLoadImage`.
-    """
-
-    def __init__(
-        self,
-        keys: KeysCollection,
-        reader: Optional[Union[ImageReader, str]] = None,
-        dtype: DtypeLike = np.float32,
-        meta_keys: Optional[KeysCollection] = None,
-        meta_key_postfix: str = DEFAULT_POST_FIX,
-        overwriting: bool = False,
-        image_only: bool = False,
-        ensure_channel_first: bool = False,
-        simple_keys=False,
-        allow_missing_keys: bool = False,
-        *args,
-        **kwargs,
-    ) -> None:
-        super(CustomLoadImaged, self).__init__(
-            keys,
-            reader,
-            dtype,
-            meta_keys,
-            meta_key_postfix,
-            overwriting,
-            image_only,
-            ensure_channel_first,
-            simple_keys,
-            allow_missing_keys,
-            *args,
-            **kwargs,
-        )
-
-        # Assign CustomLoader
-        self._loader = CustomLoadImage(
-            reader, image_only, dtype, ensure_channel_first, *args, **kwargs
-        )
-        if not isinstance(meta_key_postfix, str):
-            raise TypeError(
-                f"meta_key_postfix must be a str but is {type(meta_key_postfix).__name__}."
-            )
-        self.meta_keys = (
-            ensure_tuple_rep(None, len(self.keys))
-            if meta_keys is None
-            else ensure_tuple(meta_keys)
-        )
-        if len(self.keys) != len(self.meta_keys):
-            raise ValueError("meta_keys should have the same length as keys.")
-        self.meta_key_postfix = ensure_tuple_rep(meta_key_postfix, len(self.keys))
-        self.overwriting = overwriting
-
-
-class UnifiedITKReader(NumpyReader):
-    """
-    Unified Reader to read ".tif" and ".tiff files".
-    As the tifffile reads the images as numpy arrays, it inherits from the NumpyReader.
-    """
-
-    def __init__(
-        self, channel_dim: Optional[int] = None, **kwargs,
-    ):
-        super(UnifiedITKReader, self).__init__(channel_dim=channel_dim, **kwargs)
-        self.kwargs = kwargs
-        self.channel_dim = channel_dim
-
-    def verify_suffix(self, filename: Union[Sequence[PathLike], PathLike]) -> bool:
-        """Verify whether the file format is supported by TIFF Reader."""
-
-        suffixes: Sequence[str] = ["tif", "tiff", "png", "jpg", "bmp", "jpeg",]
-        return has_itk or is_supported_format(filename, suffixes)
-
-    def read(self, data: Union[Sequence[PathLike], PathLike], **kwargs):
-        """Read Images from the file."""
-        img_ = []
-
-        filenames: Sequence[PathLike] = ensure_tuple(data)
-        kwargs_ = self.kwargs.copy()
-        kwargs_.update(kwargs)
-
-        for name in filenames:
-            name = f"{name}"
-
-            if name.endswith(".tif") or name.endswith(".tiff"):
-                _obj = tif.imread(name)
-            else:
-                try:
-                    _obj = itk.imread(name, **kwargs_)
-                    _obj = itk.array_view_from_image(_obj, keep_axes=False)
-                except:
-                    _obj = io.imread(name)
-
-            if len(_obj.shape) == 2:
-                _obj = np.repeat(np.expand_dims(_obj, axis=-1), 3, axis=-1)
-            elif len(_obj.shape) == 3 and _obj.shape[-1] > 3:
-                _obj = _obj[:, :, :3]
-            else:
-                pass
-
-            img_.append(_obj)
-
-        return img_ if len(filenames) > 1 else img_[0]
-
-
-CustomLoadImageD = CustomLoadImageDict = CustomLoadImaged

spacr/resources/MEDIAR/train_tools/data_utils/custom/NormalizeImage.py

@@ -1,77 +0,0 @@
-import numpy as np
-from skimage import exposure
-from monai.config import KeysCollection
-
-from monai.transforms.transform import Transform
-from monai.transforms.compose import MapTransform
-
-from typing import Dict, Hashable, Mapping
-
-
-__all__ = [
-    "CustomNormalizeImage",
-    "CustomNormalizeImageD",
-    "CustomNormalizeImageDict",
-    "CustomNormalizeImaged",
-]
-
-
-class CustomNormalizeImage(Transform):
-    """Normalize the image."""
-
-    def __init__(self, percentiles=[0, 99.5], channel_wise=False):
-        self.lower, self.upper = percentiles
-        self.channel_wise = channel_wise
-
-    def _normalize(self, img) -> np.ndarray:
-        non_zero_vals = img[np.nonzero(img)]
-        percentiles = np.percentile(non_zero_vals, [self.lower, self.upper])
-        img_norm = exposure.rescale_intensity(
-            img, in_range=(percentiles[0], percentiles[1]), out_range="uint8"
-        )
-
-        return img_norm.astype(np.uint8)
-
-    def __call__(self, img: np.ndarray) -> np.ndarray:
-        if self.channel_wise:
-            pre_img_data = np.zeros(img.shape, dtype=np.uint8)
-            for i in range(img.shape[-1]):
-                img_channel_i = img[:, :, i]
-
-                if len(img_channel_i[np.nonzero(img_channel_i)]) > 0:
-                    pre_img_data[:, :, i] = self._normalize(img_channel_i)
-
-            img = pre_img_data
-
-        else:
-            img = self._normalize(img)
-
-        return img
-
-
-class CustomNormalizeImaged(MapTransform):
-    """Dictionary-based wrapper of NormalizeImage"""
-
-    def __init__(
-        self,
-        keys: KeysCollection,
-        percentiles=[1, 99],
-        channel_wise: bool = False,
-        allow_missing_keys: bool = False,
-    ):
-        super(CustomNormalizeImageD, self).__init__(keys, allow_missing_keys)
-        self.normalizer = CustomNormalizeImage(percentiles, channel_wise)
-
-    def __call__(
-        self, data: Mapping[Hashable, np.ndarray]
-    ) -> Dict[Hashable, np.ndarray]:
-
-        d = dict(data)
-
-        for key in self.keys:
-            d[key] = self.normalizer(d[key])
-
-        return d
-
-
-CustomNormalizeImageD = CustomNormalizeImageDict = CustomNormalizeImaged

spacr/resources/MEDIAR/train_tools/data_utils/custom/__init__.py

@@ -1,3 +0,0 @@
-from .LoadImage import *
-from .NormalizeImage import *
-from .CellAware import *