GANDLF 0.1.3.dev20250202__py3-none-any.whl → 0.1.6.dev20251109__py3-none-any.whl

GANDLF/metrics/metric_calculators.py

@@ -0,0 +1,102 @@
+import torch
+from copy import deepcopy
+from GANDLF.metrics import get_metrics
+from abc import ABC, abstractmethod
+from typing import Union
+
+
+class AbstractMetricCalculator(ABC):
+    def __init__(self, params: dict):
+        super().__init__()
+        self.params = deepcopy(params)
+        self._initialize_metrics_dict()
+
+    def _initialize_metrics_dict(self):
+        self.metrics_calculators = get_metrics(self.params)
+
+    def _process_metric_value(self, metric_value: Union[torch.Tensor, float]):
+        if isinstance(metric_value, float):
+            return metric_value
+        if metric_value.dim() == 0:
+            return metric_value.item()
+        else:
+            return metric_value.tolist()
+
+    @staticmethod
+    def _inject_kwargs_into_params(params, **kwargs):
+        for key, value in kwargs.items():
+            params[key] = value
+        return params
+
+    @abstractmethod
+    def __call__(
+        self, prediction: torch.Tensor, target: torch.Tensor, **kwargs
+    ) -> torch.Tensor:
+        pass
+
+
+class MetricCalculatorSDNet(AbstractMetricCalculator):
+    def __init__(self, params):
+        super().__init__(params)
+
+    def __call__(self, prediction: torch.Tensor, target: torch.Tensor, **kwargs):
+        params = deepcopy(self.params)
+        params = self._inject_kwargs_into_params(params, **kwargs)
+
+        metric_results = {}
+
+        for metric_name, metric_calculator in self.metrics_calculators.items():
+            metric_value = (
+                metric_calculator(prediction[0], target.squeeze(-1), params)
+                .detach()
+                .cpu()
+            )
+            metric_results[metric_name] = self._process_metric_value(metric_value)
+        return metric_results
+
+
+class MetricCalculatorDeepSupervision(AbstractMetricCalculator):
+    def __init__(self, params):
+        super().__init__(params)
+
+    def __call__(self, prediction: torch.Tensor, target: torch.Tensor, **kwargs):
+        params = deepcopy(self.params)
+        params = self._inject_kwargs_into_params(params, **kwargs)
+        metric_results = {}
+
+        for metric_name, metric_calculator in self.metrics_calculators.items():
+            metric_results[metric_name] = 0.0
+            for i, _ in enumerate(prediction):
+                metric_value = (
+                    metric_calculator(prediction[i], target[i], params).detach().cpu()
+                )
+                metric_results[metric_name] += self._process_metric_value(metric_value)
+        return metric_results
+
+
+class MetricCalculatorSimple(AbstractMetricCalculator):
+    def __init__(self, params):
+        super().__init__(params)
+
+    def __call__(self, prediction: torch.Tensor, target: torch.Tensor, **kwargs):
+        params = deepcopy(self.params)
+        params = self._inject_kwargs_into_params(params, **kwargs)
+        metric_results = {}
+
+        for metric_name, metric_calculator in self.metrics_calculators.items():
+            metric_value = metric_calculator(prediction, target, params).detach().cpu()
+            metric_results[metric_name] = self._process_metric_value(metric_value)
+        return metric_results
+
+
+class MetricCalculatorFactory:
+    def __init__(self, params: dict):
+        self.params = params
+
+    def get_metric_calculator(self) -> AbstractMetricCalculator:
+        if self.params["model"]["architecture"] == "sdnet":
+            return MetricCalculatorSDNet(self.params)
+        elif "deep" in self.params["model"]["architecture"].lower():
+            return MetricCalculatorDeepSupervision(self.params)
+        else:
+            return MetricCalculatorSimple(self.params)

GANDLF/metrics/panoptica_config_brats.yaml

@@ -0,0 +1,56 @@
+!Panoptica_Evaluator
+decision_metric: null
+decision_threshold: null
+edge_case_handler: !EdgeCaseHandler
+  empty_list_std: !EdgeCaseResult NAN
+  listmetric_zeroTP_handling:
+    !Metric DSC: !MetricZeroTPEdgeCaseHandling {empty_prediction_result: !EdgeCaseResult ZERO,
+      empty_reference_result: !EdgeCaseResult ZERO, no_instances_result: !EdgeCaseResult NAN,
+      normal: !EdgeCaseResult ZERO}
+    !Metric clDSC: !MetricZeroTPEdgeCaseHandling {empty_prediction_result: !EdgeCaseResult ZERO,
+      empty_reference_result: !EdgeCaseResult ZERO, no_instances_result: !EdgeCaseResult NAN,
+      normal: !EdgeCaseResult ZERO}
+    !Metric IOU: !MetricZeroTPEdgeCaseHandling {empty_prediction_result: !EdgeCaseResult ZERO,
+      empty_reference_result: !EdgeCaseResult ZERO, no_instances_result: !EdgeCaseResult NAN,
+      normal: !EdgeCaseResult ZERO}
+    !Metric NSD: !MetricZeroTPEdgeCaseHandling {empty_prediction_result: !EdgeCaseResult INF,
+      empty_reference_result: !EdgeCaseResult INF, no_instances_result: !EdgeCaseResult NAN,
+      normal: !EdgeCaseResult INF}
+    !Metric HD95: !MetricZeroTPEdgeCaseHandling {empty_prediction_result: !EdgeCaseResult INF,
+      empty_reference_result: !EdgeCaseResult INF, no_instances_result: !EdgeCaseResult NAN,
+      normal: !EdgeCaseResult INF}
+    !Metric RVD: !MetricZeroTPEdgeCaseHandling {empty_prediction_result: !EdgeCaseResult NAN,
+      empty_reference_result: !EdgeCaseResult NAN, no_instances_result: !EdgeCaseResult NAN,
+      normal: !EdgeCaseResult NAN}
+    !Metric RVAE: !MetricZeroTPEdgeCaseHandling {empty_prediction_result: !EdgeCaseResult NAN,
+      empty_reference_result: !EdgeCaseResult NAN, no_instances_result: !EdgeCaseResult NAN,
+      normal: !EdgeCaseResult NAN}
+expected_input: !InputType SEMANTIC
+global_metrics: [!Metric DSC]
+instance_approximator: !ConnectedComponentsInstanceApproximator {cca_backend: null}
+instance_matcher: !NaiveThresholdMatching {allow_many_to_one: false, matching_metric: !Metric IOU,
+  matching_threshold: 0.5}
+instance_metrics: [!Metric DSC, !Metric IOU, !Metric RVD, !Metric NSD, !Metric HD95]
+log_times: false
+save_group_times: false
+segmentation_class_groups: !SegmentationClassGroups
+  groups:
+    snfh: !LabelGroup
+      single_instance: false
+      value_labels: [2]
+    et: !LabelGroup
+      single_instance: false
+      value_labels: [3]
+    netc: !LabelGroup
+      single_instance: false
+      value_labels: [1]
+    rc: !LabelGroup
+      single_instance: false
+      value_labels: [4]
+    tc: !LabelMergeGroup
+      single_instance: false
+      value_labels: [1, 3, 4]
+    wt: !LabelMergeGroup
+      single_instance: false
+      value_labels: [1, 2, 3, 4]
+verbose: false

GANDLF/metrics/segmentation_panoptica.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+import os
+
+from typing import Optional
+import numpy as np
+
+from panoptica import Panoptica_Evaluator
+
+
+def generate_instance_segmentation(
+    prediction: np.ndarray,
+    target: np.ndarray,
+    parameters: dict,
+    panoptica_config_path: Optional[str] = None,
+) -> dict:
+    """
+    Evaluate a single exam using Panoptica.
+
+    Args:
+        prediction (np.ndarray): The input prediction containing objects.
+        label_path (str): The path to the reference label.
+        target (np.ndarray): The input target containing objects.
+        parameters (dict): The GaNDLF parameters from which panoptica config is to be extracted.
+        panoptica_config_path (str): The path to the Panoptica configuration file.
+
+    Returns:
+        dict: The evaluation results.
+    """
+
+    os.environ["PANOPTICA_CITATION_REMINDER"] = "False"
+
+    # the parameters dict takes precedence over the panoptica_config_path
+    evaluator = parameters.get("panoptica_config", None)
+    if evaluator is None:
+        cwd = Path(__file__).parent.absolute()
+        panoptica_config_path = (
+            str(cwd / "panoptica_config_brats.yaml")
+            if panoptica_config_path is None
+            else panoptica_config_path
+        )
+        evaluator = Panoptica_Evaluator.load_from_config(panoptica_config_path)
+
+    assert evaluator is not None, "Panoptica evaluator could not be initialized."
+
+    # call evaluate
+    group2result = evaluator.evaluate(prediction_arr=prediction, reference_arr=target)
+
+    results = {k: r.to_dict() for k, r in group2result.items()}
+    return results

GANDLF/models/__init__.py

@@ -36,6 +36,7 @@ from .MSDNet import MSDNet
 from .brain_age import brainage
 from .unetr import unetr
 from .transunet import transunet
+from .modelBase import ModelBase
 
 # Define a dictionary of model architectures and corresponding functions
 global_models_dict = {
@@ -110,7 +111,7 @@ global_models_dict = {
 }
 
 
-def get_model(params):
+def get_model(params: dict) -> ModelBase:
     """
     Function to get the model definition.
 
@@ -118,6 +119,10 @@ def get_model(params):
         params (dict): The parameters' dictionary.
 
     Returns:
-        model (torch.nn.Module): The model definition.
+        model (ModelBase): The model definition.
     """
-    return global_models_dict[params["model"]["architecture"]](parameters=params)
+    chosen_model = params["model"]["architecture"].lower()
+    assert (
+        chosen_model in global_models_dict
+    ), f"Could not find the requested model '{params['model']['architecture']}'"
+    return global_models_dict[chosen_model](parameters=params)