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

spacr/resources/MEDIAR/config/step3_prediction/ensemble_tta.json

@@ -1,23 +0,0 @@
-{
-    "pred_setups":{
-        "name": "ensemble_mediar",
-        "input_path":"/home/gihun/MEDIAR/data/Official/Tuning/images",
-        "output_path": "./results/mediar_ensemble_tta",
-        "make_submission": true,
-        "model_path1": "./weights/finetuned/from_phase1.pth",
-        "model_path2": "./weights/finetuned/from_phase2.pth",
-        "device": "cuda:0",
-        "model":{
-            "name": "mediar-former",
-            "params": {
-                    "encoder_name":"mit_b5",        
-                    "decoder_channels": [1024, 512, 256, 128, 64],
-                    "decoder_pab_channels": 256,
-                    "in_channels":3, 
-                    "classes":3
-            }
-        },
-        "exp_name": "mediar_ensemble_tta",
-        "algo_params": {"use_tta": true}
-    }
-}

spacr/resources/MEDIAR/core/BasePredictor.py

@@ -1,120 +0,0 @@
-import torch
-import numpy as np
-import time, os
-import tifffile as tif
-
-from datetime import datetime
-from zipfile import ZipFile
-from pytz import timezone
-
-from train_tools.data_utils.transforms import get_pred_transforms
-
-
-class BasePredictor:
-    def __init__(
-        self,
-        model,
-        device,
-        input_path,
-        output_path,
-        make_submission=False,
-        exp_name=None,
-        algo_params=None,
-    ):
-        self.model = model
-        self.device = device
-        self.input_path = input_path
-        self.output_path = output_path
-        self.make_submission = make_submission
-        self.exp_name = exp_name
-
-        # Assign algoritm-specific arguments
-        if algo_params:
-            self.__dict__.update((k, v) for k, v in algo_params.items())
-
-        # Prepare inference environments
-        self._setups()
-
-    @torch.no_grad()
-    def conduct_prediction(self):
-        self.model.to(self.device)
-        self.model.eval()
-        total_time = 0
-        total_times = []
-
-        for img_name in self.img_names:
-            img_data = self._get_img_data(img_name)
-            img_data = img_data.to(self.device)
-
-            start = time.time()
-
-            pred_mask = self._inference(img_data)
-            pred_mask = self._post_process(pred_mask.squeeze(0).cpu().numpy())
-            self.write_pred_mask(
-                pred_mask, self.output_path, img_name, self.make_submission
-            )
-
-            end = time.time()
-
-            time_cost = end - start
-            total_times.append(time_cost)
-            total_time += time_cost
-            print(
-                f"Prediction finished: {img_name}; img size = {img_data.shape}; costing: {time_cost:.2f}s"
-            )
-
-        print(f"\n Total Time Cost: {total_time:.2f}s")
-
-        if self.make_submission:
-            fname = "%s.zip" % self.exp_name
-
-            os.makedirs("./submissions", exist_ok=True)
-            submission_path = os.path.join("./submissions", fname)
-
-            with ZipFile(submission_path, "w") as zipObj2:
-                pred_names = sorted(os.listdir(self.output_path))
-                for pred_name in pred_names:
-                    pred_path = os.path.join(self.output_path, pred_name)
-                    zipObj2.write(pred_path)
-
-            print("\n>>>>> Submission file is saved at: %s\n" % submission_path)
-
-        return time_cost
-
-    def write_pred_mask(self, pred_mask, output_dir, image_name, submission=False):
-
-        # All images should contain at least 5 cells
-        if submission:
-            if not (np.max(pred_mask) > 5):
-                print("[!Caution] Only %d Cells Detected!!!\n" % np.max(pred_mask))
-
-        file_name = image_name.split(".")[0]
-        file_name = file_name + "_label.tiff"
-        file_path = os.path.join(output_dir, file_name)
-
-        tif.imwrite(file_path, pred_mask, compression="zlib")
-
-    def _setups(self):
-        self.pred_transforms = get_pred_transforms()
-        os.makedirs(self.output_path, exist_ok=True)
-
-        now = datetime.now(timezone("Asia/Seoul"))
-        dt_string = now.strftime("%m%d_%H%M")
-        self.exp_name = (
-            self.exp_name + dt_string if self.exp_name is not None else dt_string
-        )
-
-        self.img_names = sorted(os.listdir(self.input_path))
-
-    def _get_img_data(self, img_name):
-        img_path = os.path.join(self.input_path, img_name)
-        img_data = self.pred_transforms(img_path)
-        img_data = img_data.unsqueeze(0)
-
-        return img_data
-
-    def _inference(self, img_data):
-        raise NotImplementedError
-
-    def _post_process(self, pred_mask):
-        raise NotImplementedError

spacr/resources/MEDIAR/core/BaseTrainer.py

@@ -1,240 +0,0 @@
-import torch
-import numpy as np
-from tqdm import tqdm
-from monai.inferers import sliding_window_inference
-from monai.metrics import CumulativeAverage
-from monai.transforms import (
-    Activations,
-    AsDiscrete,
-    Compose,
-    EnsureType,
-)
-
-import os, sys
-import copy
-
-sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), "../")))
-
-from core.utils import print_learning_device, print_with_logging
-from train_tools.measures import evaluate_f1_score_cellseg
-
-
-class BaseTrainer:
-    """Abstract base class for trainer implementations"""
-
-    def __init__(
-        self,
-        model,
-        dataloaders,
-        optimizer,
-        scheduler=None,
-        criterion=None,
-        num_epochs=100,
-        device="cuda:0",
-        no_valid=False,
-        valid_frequency=1,
-        amp=False,
-        algo_params=None,
-    ):
-        self.model = model.to(device)
-        self.dataloaders = dataloaders
-        self.optimizer = optimizer
-        self.scheduler = scheduler
-        self.criterion = criterion
-        self.num_epochs = num_epochs
-        self.no_valid = no_valid
-        self.valid_frequency = valid_frequency
-        self.device = device
-        self.amp = amp
-        self.best_weights = None
-        self.best_f1_score = 0.1
-
-        # FP-16 Scaler
-        self.scaler = torch.cuda.amp.GradScaler() if amp else None
-
-        # Assign algoritm-specific arguments
-        if algo_params:
-            self.__dict__.update((k, v) for k, v in algo_params.items())
-
-        # Cumulitive statistics
-        self.loss_metric = CumulativeAverage()
-        self.f1_metric = CumulativeAverage()
-
-        # Post-processing functions
-        self.post_pred = Compose(
-            [EnsureType(), Activations(softmax=True), AsDiscrete(threshold=0.5)]
-        )
-        self.post_gt = Compose([EnsureType(), AsDiscrete(to_onehot=None)])
-
-    def train(self):
-        """Train the model"""
-
-        # Print learning device name
-        print_learning_device(self.device)
-
-        # Learning process
-        for epoch in range(1, self.num_epochs + 1):
-            print(f"[Round {epoch}/{self.num_epochs}]")
-
-            # Train Epoch Phase
-            print(">>> Train Epoch")
-            train_results = self._epoch_phase("train")
-            print_with_logging(train_results, epoch)
-
-            if self.scheduler is not None:
-                self.scheduler.step()
-
-            if epoch % self.valid_frequency == 0:
-                if not self.no_valid:
-                    # Valid Epoch Phase
-                    print(">>> Valid Epoch")
-                    valid_results = self._epoch_phase("valid")
-                    print_with_logging(valid_results, epoch)
-
-                    if "Valid_F1_Score" in valid_results.keys():
-                        current_f1_score = valid_results["Valid_F1_Score"]
-                        self._update_best_model(current_f1_score)
-                else:
-                    print(">>> TuningSet Epoch")
-                    tuning_cell_counts = self._tuningset_evaluation()
-                    tuning_count_dict = {"TuningSet_Cell_Count": tuning_cell_counts}
-                    print_with_logging(tuning_count_dict, epoch)
-
-                    current_cell_count = tuning_cell_counts
-                    self._update_best_model(current_cell_count)
-
-            print("-" * 50)
-
-            self.best_f1_score = 0
-
-        if self.best_weights is not None:
-            self.model.load_state_dict(self.best_weights)
-
-    def _epoch_phase(self, phase):
-        """Learning process for 1 Epoch (for different phases).
-
-        Args:
-            phase (str): "train", "valid", "test"
-
-        Returns:
-            dict: statistics for the phase results
-        """
-        phase_results = {}
-
-        # Set model mode
-        self.model.train() if phase == "train" else self.model.eval()
-
-        # Epoch process
-        for batch_data in tqdm(self.dataloaders[phase]):
-            images = batch_data["img"].to(self.device)
-            labels = batch_data["label"].to(self.device)
-            self.optimizer.zero_grad()
-
-            # Forward pass
-            with torch.set_grad_enabled(phase == "train"):
-                outputs = self.model(images)
-                loss = self.criterion(outputs, labels)
-                self.loss_metric.append(loss)
-
-            # Backward pass
-            if phase == "train":
-                loss.backward()
-                self.optimizer.step()
-
-        # Update metrics
-        phase_results = self._update_results(
-            phase_results, self.loss_metric, "loss", phase
-        )
-
-        return phase_results
-
-    @torch.no_grad()
-    def _tuningset_evaluation(self):
-        cell_counts_total = []
-        self.model.eval()
-
-        for batch_data in tqdm(self.dataloaders["tuning"]):
-            images = batch_data["img"].to(self.device)
-            if images.shape[-1] > 5000:
-                continue
-
-            outputs = sliding_window_inference(
-                images,
-                roi_size=512,
-                sw_batch_size=4,
-                predictor=self.model,
-                padding_mode="constant",
-                mode="gaussian",
-            )
-
-            outputs = outputs.squeeze(0)
-            outputs, _ = self._post_process(outputs, None)
-            count = len(np.unique(outputs) - 1)
-            cell_counts_total.append(count)
-
-        cell_counts_total_sum = np.sum(cell_counts_total)
-        print("Cell Counts Total: (%d)" % (cell_counts_total_sum))
-
-        return cell_counts_total_sum
-
-    def _update_results(self, phase_results, metric, metric_key, phase="train"):
-        """Aggregate and flush metrics
-
-        Args:
-            phase_results (dict): base dictionary to log metrics
-            metric (_type_): cumulated metrics
-            metric_key (_type_): name of metric
-            phase (str, optional): current phase name. Defaults to "train".
-
-        Returns:
-            dict: dictionary of metrics for the current phase
-        """
-
-        # Refine metrics name
-        metric_key = "_".join([phase, metric_key]).title()
-
-        # Aggregate metrics
-        metric_item = round(metric.aggregate().item(), 4)
-
-        # Log metrics to dictionary
-        phase_results[metric_key] = metric_item
-
-        # Flush metrics
-        metric.reset()
-
-        return phase_results
-
-    def _update_best_model(self, current_f1_score):
-        if current_f1_score > self.best_f1_score:
-            self.best_weights = copy.deepcopy(self.model.state_dict())
-            self.best_f1_score = current_f1_score
-            print(
-                "\n>>>> Update Best Model with score: {}\n".format(self.best_f1_score)
-            )
-        else:
-            pass
-
-    def _inference(self, images, phase="train"):
-        """inference methods for different phase"""
-        if phase != "train":
-            outputs = sliding_window_inference(
-                images,
-                roi_size=512,
-                sw_batch_size=4,
-                predictor=self.model,
-                padding_mode="reflect",
-                mode="gaussian",
-                overlap=0.5,
-            )
-        else:
-            outputs = self.model(images)
-
-        return outputs
-
-    def _post_process(self, outputs, labels):
-        return outputs, labels
-
-    def _get_f1_metric(self, masks_pred, masks_true):
-        f1_score = evaluate_f1_score_cellseg(masks_true, masks_pred)[-1]
-
-        return f1_score

spacr/resources/MEDIAR/core/Baseline/Predictor.py

@@ -1,59 +0,0 @@
-import torch
-import os, sys
-from skimage import morphology, measure
-from monai.inferers import sliding_window_inference
-
-sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), "../../")))
-
-from core.BasePredictor import BasePredictor
-
-__all__ = ["Predictor"]
-
-
-class Predictor(BasePredictor):
-    def __init__(
-        self,
-        model,
-        device,
-        input_path,
-        output_path,
-        make_submission=False,
-        exp_name=None,
-        algo_params=None,
-    ):
-        super(Predictor, self).__init__(
-            model,
-            device,
-            input_path,
-            output_path,
-            make_submission,
-            exp_name,
-            algo_params,
-        )
-
-    def _inference(self, img_data):
-        pred_mask = sliding_window_inference(
-            img_data,
-            512,
-            4,
-            self.model,
-            padding_mode="constant",
-            mode="gaussian",
-            overlap=0.6,
-        )
-
-        return pred_mask
-
-    def _post_process(self, pred_mask):
-        # Get probability map from the predicted logits
-        pred_mask = torch.from_numpy(pred_mask)
-        pred_mask = torch.softmax(pred_mask, dim=0)
-        pred_mask = pred_mask[1].cpu().numpy()
-
-        # Apply morphological post-processing
-        pred_mask = pred_mask > 0.5
-        pred_mask = morphology.remove_small_holes(pred_mask, connectivity=1)
-        pred_mask = morphology.remove_small_objects(pred_mask, 16)
-        pred_mask = measure.label(pred_mask)
-
-        return pred_mask

spacr/resources/MEDIAR/core/Baseline/Trainer.py

@@ -1,113 +0,0 @@
-import torch
-import os, sys
-import monai
-
-from monai.data import decollate_batch
-
-sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), "../../")))
-
-from core.BaseTrainer import BaseTrainer
-from core.Baseline.utils import create_interior_onehot, identify_instances_from_classmap
-from train_tools.measures import evaluate_f1_score_cellseg
-from tqdm import tqdm
-
-__all__ = ["Trainer"]
-
-
-class Trainer(BaseTrainer):
-    def __init__(
-        self,
-        model,
-        dataloaders,
-        optimizer,
-        scheduler=None,
-        criterion=None,
-        num_epochs=100,
-        device="cuda:0",
-        no_valid=False,
-        valid_frequency=1,
-        amp=False,
-        algo_params=None,
-    ):
-        super(Trainer, self).__init__(
-            model,
-            dataloaders,
-            optimizer,
-            scheduler,
-            criterion,
-            num_epochs,
-            device,
-            no_valid,
-            valid_frequency,
-            amp,
-            algo_params,
-        )
-
-        # Dice loss as segmentation criterion
-        self.criterion = monai.losses.DiceCELoss(softmax=True)
-
-    def _epoch_phase(self, phase):
-        """Learning process for 1 Epoch."""
-
-        phase_results = {}
-
-        # Set model mode
-        self.model.train() if phase == "train" else self.model.eval()
-
-        # Epoch process
-        for batch_data in tqdm(self.dataloaders[phase]):
-            images = batch_data["img"].to(self.device)
-            labels = batch_data["label"].to(self.device)
-            self.optimizer.zero_grad()
-
-            # Map label masks to 3-class onehot map
-            labels_onehot = create_interior_onehot(labels)
-
-            # Forward pass
-            with torch.set_grad_enabled(phase == "train"):
-                outputs = self._inference(images, phase)
-                loss = self.criterion(outputs, labels_onehot)
-                self.loss_metric.append(loss)
-
-                if phase != "train":
-                    f1_score = self._get_f1_metric(outputs, labels)
-                    self.f1_metric.append(f1_score)
-
-            # Backward pass
-            if phase == "train":
-                # For the mixed precision training
-                if self.amp:
-                    self.scaler.scale(loss).backward()
-                    self.scaler.unscale_(self.optimizer)
-                    self.scaler.step(self.optimizer)
-                    self.scaler.update()
-
-                else:
-                    loss.backward()
-                    self.optimizer.step()
-
-        # Update metrics
-        phase_results = self._update_results(
-            phase_results, self.loss_metric, "loss", phase
-        )
-
-        if phase != "train":
-            phase_results = self._update_results(
-                phase_results, self.f1_metric, "f1_score", phase
-            )
-
-        return phase_results
-
-    def _post_process(self, outputs, labels_onehot):
-        """Conduct post-processing for outputs & labels."""
-        outputs = [self.post_pred(i) for i in decollate_batch(outputs)]
-        labels_onehot = [self.post_gt(i) for i in decollate_batch(labels_onehot)]
-
-        return outputs, labels_onehot
-
-    def _get_f1_metric(self, masks_pred, masks_true):
-        masks_pred = identify_instances_from_classmap(masks_pred[0])
-        masks_true = masks_true.squeeze(0).squeeze(0).cpu().numpy()
-        f1_score = evaluate_f1_score_cellseg(masks_true, masks_pred)[-1]
-
-        return f1_score

spacr/resources/MEDIAR/core/Baseline/__init__.py

@@ -1,2 +0,0 @@
-from .Trainer import *
-from .Predictor import *

spacr/resources/MEDIAR/core/Baseline/utils.py

@@ -1,80 +0,0 @@
-"""
-Adapted from the following references:
-[1] https://github.com/JunMa11/NeurIPS-CellSeg/blob/main/baseline/model_training_3class.py
-
-"""
-
-import torch
-import numpy as np
-from skimage import segmentation, morphology, measure
-import monai
-
-
-__all__ = ["create_interior_onehot", "identify_instances_from_classmap"]
-
-
-@torch.no_grad()
-def identify_instances_from_classmap(
-    class_map, cell_class=1, threshold=0.5, from_logits=True
-):
-    """Identification of cell instances from the class map"""
-
-    if from_logits:
-        class_map = torch.softmax(class_map, dim=0)  # (C, H, W)
-
-    # Convert probability map to binary mask
-    pred_mask = class_map[cell_class].cpu().numpy()
-
-    # Apply morphological postprocessing
-    pred_mask = pred_mask > threshold
-    pred_mask = morphology.remove_small_holes(pred_mask, connectivity=1)
-    pred_mask = morphology.remove_small_objects(pred_mask, 16)
-    pred_mask = measure.label(pred_mask)
-
-    return pred_mask
-
-
-@torch.no_grad()
-def create_interior_onehot(inst_maps):
-    """
-    interior : (H,W), np.uint8
-        three-class map, values: 0,1,2
-        0: background
-        1: interior
-        2: boundary
-    """
-    device = inst_maps.device
-
-    # Get (np.int16) array corresponding to label masks: (B, 1, H, W)
-    inst_maps = inst_maps.squeeze(1).cpu().numpy().astype(np.int16)
-
-    interior_maps = []
-
-    for inst_map in inst_maps:
-        # Create interior-edge map
-        boundary = segmentation.find_boundaries(inst_map, mode="inner")
-
-        # Refine interior-edge map
-        boundary = morphology.binary_dilation(boundary, morphology.disk(1))
-
-        # Assign label classes
-        interior_temp = np.logical_and(~boundary, inst_map > 0)
-
-        # interior_temp[boundary] = 0
-        interior_temp = morphology.remove_small_objects(interior_temp, min_size=16)
-        interior = np.zeros_like(inst_map, dtype=np.uint8)
-        interior[interior_temp] = 1
-        interior[boundary] = 2
-
-        interior_maps.append(interior)
-
-    # Aggregate interior_maps for batch
-    interior_maps = np.stack(interior_maps, axis=0).astype(np.uint8)
-
-    # Reshape as original label shape: (B, H, W)
-    interior_maps = torch.from_numpy(interior_maps).unsqueeze(1).to(device)
-
-    # Obtain one-hot map for batch
-    interior_onehot = monai.networks.one_hot(interior_maps, num_classes=3)
-
-    return interior_onehot