GANDLF 0.1.3.dev20250319__py3-none-any.whl → 0.1.4.dev20250503__py3-none-any.whl

GANDLF/data/lightning_datamodule.py

@@ -0,0 +1,119 @@
+import lightning.pytorch as pl
+from GANDLF.compute.generic import (
+    TrainingSubsetDataParser,
+    ValidationSubsetDataParser,
+    TestSubsetDataParser,
+    InferenceSubsetDataParserRadiology,
+)
+from torch.utils.data import DataLoader as TorchDataLoader
+from copy import deepcopy
+
+
+class GandlfTrainingDatamodule(pl.LightningDataModule):
+    def __init__(self, data_dict_files: dict, parameters_dict: dict):
+        super().__init__()
+
+        # Batch size here and reinitialization of dataloader parsers is used
+        # in automatic batch size tuning
+
+        self.batch_size = parameters_dict["batch_size"]
+
+        # This init procedure is extreme hack, but the only way to get around the
+        # need to modify the parameters dict during the parsing procedure
+
+        params = deepcopy(parameters_dict)
+
+        train_subset_parser = TrainingSubsetDataParser(
+            data_dict_files["training"], params
+        )
+        self.training_dataset = train_subset_parser.create_subset_dataset()
+        params = train_subset_parser.get_params_extended_with_subset_data()
+
+        val_subset_parser = ValidationSubsetDataParser(
+            data_dict_files["validation"], params
+        )
+        self.validation_dataset = val_subset_parser.create_subset_dataset()
+        params = val_subset_parser.get_params_extended_with_subset_data()
+
+        testing_data = data_dict_files.get("testing", None)
+        self.test_dataset = None
+        if testing_data is not None:
+            test_subset_parser = TestSubsetDataParser(testing_data, params)
+            self.test_dataset = test_subset_parser.create_subset_dataset()
+            params = test_subset_parser.get_params_extended_with_subset_data()
+
+        self.parameters_dict = params
+
+    def _get_dataloader(self, dataset, batch_size: int, shuffle: bool):
+        return TorchDataLoader(
+            dataset,
+            batch_size=batch_size,
+            shuffle=shuffle,
+            num_workers=self.updated_parameters_dict.get("num_workers_dataloader", 1),
+            pin_memory=self.updated_parameters_dict.get("pin_memory_dataloader", False),
+            prefetch_factor=self.updated_parameters_dict.get(
+                "prefetch_factor_dataloader", 2
+            ),
+        )
+
+    @property
+    def updated_parameters_dict(self):
+        return self.parameters_dict
+
+    def train_dataloader(self):
+        self.updated_parameters_dict["batch_size"] = self.batch_size
+        return self._get_dataloader(
+            self.training_dataset, self.batch_size, shuffle=True
+        )
+
+    def val_dataloader(self):
+        return self._get_dataloader(
+            self.validation_dataset, batch_size=1, shuffle=False
+        )
+
+    def test_dataloader(self):
+        if self.test_dataset is None:
+            return None
+        return self._get_dataloader(self.test_dataset, batch_size=1, shuffle=False)
+
+
+class GandlfInferenceDatamodule(pl.LightningDataModule):
+    def __init__(self, dataframe, parameters_dict):
+        super().__init__()
+        self.dataframe = dataframe
+        params = deepcopy(parameters_dict)
+        self.parameters_dict = params
+        if self.parameters_dict["modality"] == "rad":
+            inference_subset_data_parser_radiology = InferenceSubsetDataParserRadiology(
+                self.dataframe, params
+            )
+            self.inference_dataset = (
+                inference_subset_data_parser_radiology.create_subset_dataset()
+            )
+
+            self.parameters_dict = (
+                inference_subset_data_parser_radiology.get_params_extended_with_subset_data()
+            )
+
+    @property
+    def updated_parameters_dict(self):
+        return self.parameters_dict
+
+    def predict_dataloader(self):
+        if self.parameters_dict["modality"] == "rad":
+            return TorchDataLoader(
+                self.inference_dataset,
+                batch_size=1,
+                shuffle=False,
+                num_workers=self.updated_parameters_dict.get(
+                    "num_workers_dataloader", 1
+                ),
+                pin_memory=self.updated_parameters_dict.get(
+                    "pin_memory_dataloader", False
+                ),
+                prefetch_factor=self.updated_parameters_dict.get(
+                    "prefetch_factor_dataloader", 2
+                ),
+            )
+        elif self.parameters_dict["modality"] in ["path", "histo"]:
+            return self.dataframe.iterrows()

GANDLF/entrypoints/run.py

@@ -14,17 +14,19 @@ from GANDLF.cli import main_run, copyrightMessage
 from GANDLF.entrypoints import append_copyright_to_help
 from GANDLF.utils import logger_setup
 
+from warnings import warn
+
 
 def _run(
     config: str,
     input_data: str,
     train_flag: bool,
     model_dir: str,
-    device: str,
     reset_flag: bool,
     resume_flag: bool,
+    device: Optional[str],
     output_path: Optional[str],
-    _profile: Optional[bool] = False,
+    profile: Optional[bool] = False,
 ):
     if model_dir is None and output_path:
         model_dir = output_path
@@ -49,7 +51,11 @@ def _run(
             "'reset' and 'resume' are mutually exclusive; 'resume' will be used."
         )
         reset_flag = False
-
+    if device is not None:
+        warn(
+            "Device parameter is deprecated and has no effect. See migration guide docs.",
+            DeprecationWarning,
+        )
     # TODO: check that output_path is not passed in training mode;
     #  maybe user misconfigured the command
 
@@ -57,22 +63,20 @@ def _run(
     logging.debug(f"{input_data=}")
     logging.debug(f"{train_flag=}")
     logging.debug(f"{model_dir=}")
-    logging.debug(f"{device=}")
     logging.debug(f"{reset_flag=}")
     logging.debug(f"{resume_flag=}")
     logging.debug(f"{output_path=}")
-    logging.debug(f"{_profile=}")
+    logging.debug(f"{profile=}")
 
     main_run(
         data_csv=input_data,
         config_file=config,
         model_dir=model_dir,
         train_mode=train_flag,
-        device=device,
         resume=resume_flag,
         reset=reset_flag,
         output_dir=output_path,
-        _profile=_profile,
+        profile=profile,
     )
     print("Finished.")
 
@@ -108,21 +112,6 @@ def _run(
     help="Training: Output directory to save intermediate files and model weights; "
     "inference: location of previous training session output",
 )
-@click.option(
-    "--device",
-    "-d",
-    # TODO: Not sure it's worth to restrict this list. What about other devices?
-    #  GaNDLF guarantees to work properly with these two options, but
-    #  other values may be partially working also.
-    #  * GaNDLF code convert `-1` to `cpu` (i.e. it is expected somebody may pass -1)
-    #  * `cuda:0` should work also, isn't it? Just would not be treated as `cuda`
-    #  * Would `mps` work?
-    #  * int values (like `1`) - are they supported? (legacy mode for cuda https://pytorch.org/docs/stable/tensor_attributes.html#torch-device)
-    type=click.Choice(["cuda", "cpu"]),
-    required=True,  # FIXME: either keep default value, or set required flag
-    help="Device to perform requested session on 'cpu' or 'cuda'; "
-    "for cuda, ensure CUDA_VISIBLE_DEVICES env var is set",
-)
 @click.option(
     "--reset",
     "-rt",
@@ -154,19 +143,25 @@ def _run(
     is_flag=True,
     help="Track the run time and memory consumption for each layer",
 )
+@click.option(
+    "--device",
+    "-d",
+    type=str,
+    help="DEPRECATED - has no effect, see migration guide docs. Device to run the model on.",
+)
 @append_copyright_to_help
 def new_way(
     config: str,
     input_data: str,
     train: bool,
     model_dir: str,
-    device: str,
     reset: bool,
     resume: bool,
     output_path: str,
     raw_input: str,
     profile: bool,
     log_file: str,
+    device: str,
 ):
     """Semantic segmentation, regression, and classification for medical images using Deep Learning."""
 
@@ -176,11 +171,11 @@ def new_way(
         input_data=input_data,
         train_flag=train,
         model_dir=model_dir,
-        device=device,
         reset_flag=reset,
         resume_flag=resume,
         output_path=output_path,
-        _profile=profile,
+        profile=profile,
+        device=device,
     )
 
 
@@ -238,15 +233,7 @@ def old_way():
         type=str,
         help="Training: Output directory to save intermediate files and model weights; inference: location of previous training session output",
     )
-    parser.add_argument(
-        "-d",
-        "--device",
-        default="cuda",  # TODO: default value doesn't work as arg is required
-        metavar="",
-        type=str,
-        required=True,
-        help="Device to perform requested session on 'cpu' or 'cuda'; for cuda, ensure CUDA_VISIBLE_DEVICES env var is set",
-    )
+
     parser.add_argument(
         "-rt",
         "--reset",
@@ -278,6 +265,13 @@ def old_way():
         version="%(prog)s v{}".format(version) + "\n\n" + copyrightMessage,
         help="Show program's version number and exit.",
     )
+    parser.add_argument(
+        "-d",
+        "--device",
+        metavar="",
+        type=str,
+        help="DEPRECATED - has no effect, see migration guide docs. Device to run the model on.",
+    )
 
     # This is a dummy argument that exists to trigger MLCube mounting requirements.
     # Do not remove.
@@ -293,10 +287,10 @@ def old_way():
         input_data=args.inputdata,
         train_flag=args.train,
         model_dir=args.modeldir,
-        device=args.device,
         reset_flag=args.reset,
         resume_flag=args.resume,
         output_path=args.outputdir,
+        device=args.device,
     )
 
 

GANDLF/inference_manager.py

@@ -4,16 +4,16 @@ from typing import Optional
 
 import pandas as pd
 import torch
-import torch.nn.functional as F
-from GANDLF.compute import inference_loop
 from GANDLF.utils import get_unique_timestamp
+import lightning.pytorch as pl
+from GANDLF.models.lightning_module import GandlfLightningModule
+from GANDLF.data.lightning_datamodule import GandlfInferenceDatamodule
 
 
 def InferenceManager(
     dataframe: pd.DataFrame,
     modelDir: str,
     parameters: dict,
-    device: str,
     outputDir: Optional[str] = None,
 ) -> None:
     """
@@ -27,7 +27,7 @@ def InferenceManager(
         outputDir (Optional[str], optional): The output directory for the inference results. Defaults to None.
     """
     if outputDir is None:
-        outputDir = os.path.join(modelDir, get_unique_timestamp())
+        outputDir = os.path.join(modelDir, get_unique_timestamp(), "output_inference")
         print(
             "Output directory not provided, creating a new directory with a unique timestamp: ",
             outputDir,
@@ -43,6 +43,35 @@ def InferenceManager(
     n_folds = parameters["nested_training"]["validation"]
     modelDir_split = modelDir.split(",") if "," in modelDir else [modelDir]
 
+    # This should be handled by config parser
+    accelerator = parameters.get("accelerator", "auto")
+    allowed_accelerators = ["cpu", "gpu", "auto"]
+    # codacy ignore Generic/ReDoS: This is not a SQL query, it's an error message.
+    assert (
+        accelerator in allowed_accelerators
+    ), f"Invalid accelerator selected: {accelerator}. Please select from {allowed_accelerators}"
+    strategy = parameters.get("strategy", "auto")
+    allowed_strategies = ["auto", "ddp"]
+    # codacy ignore Generic/ReDoS: This is not a SQL query, it's an error message.
+    assert (
+        strategy in allowed_strategies
+    ), f"Invalid strategy selected: {strategy}. Please select from {allowed_strategies}"
+    precision = parameters.get("precision", "32")
+    allowed_precisions = [
+        "64",
+        "64-true",
+        "32",
+        "32-true",
+        "16",
+        "16-mixed",
+        "bf16",
+        "bf16-mixed",
+    ]
+    # codacy ignore Generic/ReDoS: This is not a SQL query, it's an error message.
+    assert (
+        precision in allowed_precisions
+    ), f"Invalid precision selected: {precision}. Please select from {allowed_precisions}"
+
     averaged_probs_list = []
     for current_modelDir in modelDir_split:
         fold_dirs = (
@@ -55,7 +84,6 @@ def InferenceManager(
             else [current_modelDir]
         )
 
-        probs_list = []
         is_classification = parameters["problem_type"] == "classification"
         parameters["model"].setdefault("type", "torch")
         class_list = (
@@ -63,27 +91,43 @@ def InferenceManager(
             if is_classification
             else None
         )
-
+        probs_list = None
         for fold_dir in fold_dirs:
-            parameters["current_fold_dir"] = fold_dir
-            inference_loop(
-                inferenceDataFromPickle=dataframe,
-                modelDir=fold_dir,
-                device=device,
-                parameters=parameters,
-                outputDir=outputDir,
+            trainer = pl.Trainer(
+                accelerator=accelerator,
+                strategy=strategy,
+                fast_dev_run=False,
+                devices=parameters.get("devices", "auto"),
+                num_nodes=parameters.get("num_nodes", 1),
+                precision=precision,
+                gradient_clip_algorithm=parameters["clip_mode"],
+                gradient_clip_val=parameters["clip_grad"],
+                max_epochs=parameters["num_epochs"],
+                sync_batchnorm=False,
+                enable_checkpointing=False,
+                logger=False,
+                num_sanity_val_steps=0,
             )
+            datamodule = GandlfInferenceDatamodule(dataframe, parameters)
+            parameters = datamodule.updated_parameters_dict
+            lightning_module = GandlfLightningModule(parameters, output_dir=fold_dir)
 
+            if parameters.get("auto_batch_size_find", False):
+                print(
+                    "Auto batch size find is not supported in inference. Dataloader batch size is always 1."
+                )
+
+            trainer.predict(lightning_module, datamodule=datamodule)
             if is_classification:
-                logits_path = os.path.join(fold_dir, "logits.csv")
-                if os.path.isfile(logits_path):
-                    fold_logits = pd.read_csv(logits_path)[class_list].values
-                    fold_logits = torch.from_numpy(fold_logits)
-                    fold_probs = F.softmax(fold_logits, dim=1)
-                    probs_list.append(fold_probs)
-
-        if is_classification and probs_list:
-            probs_list = torch.stack(probs_list)
+                prob_values_for_all_subjects_in_fold = list(
+                    lightning_module.subject_classification_class_probabilities.values()
+                )
+                if prob_values_for_all_subjects_in_fold:
+                    probs_list = torch.stack(
+                        prob_values_for_all_subjects_in_fold, dim=1
+                    )
+
+        if is_classification and probs_list is not None:
             averaged_probs_list.append(torch.mean(probs_list, 0))
 
     # this logic should be changed if we want to do multi-fold inference for histo images
@@ -93,9 +137,9 @@ def InferenceManager(
         )
         averaged_probs_df["SubjectID"] = dataframe.iloc[:, 0]
 
-        averaged_probs_across_models = torch.mean(
-            torch.stack(averaged_probs_list), 0
-        ).numpy()
+        averaged_probs_across_models = (
+            torch.mean(torch.stack(averaged_probs_list), 0).cpu().numpy()
+        )
         averaged_probs_df[class_list] = averaged_probs_across_models
         averaged_probs_df["PredictedClass"] = [
             class_list[idx] for idx in averaged_probs_across_models.argmax(axis=1)

GANDLF/losses/__init__.py

@@ -13,7 +13,6 @@ from .segmentation import (
 from .regression import CE, CEL, MSE_loss, L1_loss
 from .hybrid import DCCE, DCCE_Logits, DC_Focal
 
-
 # global defines for the losses
 global_losses_dict = {
     "dc": MCD_loss,
@@ -38,3 +37,26 @@ global_losses_dict = {
     "focal": FocalLoss,
     "dc_focal": DC_Focal,
 }
+
+
+def get_loss(params: dict) -> object:
+    """
+    Function to get the loss definition.
+
+    Args:
+        params (dict): The parameters' dictionary.
+
+    Returns:
+        loss (object): The loss definition.
+    """
+    # TODO This check looks like legacy code, should we have it?
+
+    if isinstance(params["loss_function"], dict):
+        chosen_loss = list(params["loss_function"].keys())[0].lower()
+    else:
+        chosen_loss = params["loss_function"].lower()
+    assert (
+        chosen_loss in global_losses_dict
+    ), f"Could not find the requested loss function '{params['loss_function']}'"
+
+    return global_losses_dict[chosen_loss]

GANDLF/losses/loss_calculators.py

@@ -0,0 +1,79 @@
+import torch
+from abc import ABC, abstractmethod
+
+from GANDLF.losses import get_loss
+
+
+class AbstractLossCalculator(ABC):
+    def __init__(self, params: dict):
+        super().__init__()
+        self.params = params
+        self._initialize_loss()
+
+    def _initialize_loss(self):
+        self.loss = get_loss(self.params)
+
+    @abstractmethod
+    def __call__(
+        self, prediction: torch.Tensor, target: torch.Tensor, *args
+    ) -> torch.Tensor:
+        pass
+
+
+class LossCalculatorSDNet(AbstractLossCalculator):
+    def __init__(self, params):
+        super().__init__(params)
+        self.l1_loss = get_loss(params)
+        self.kld_loss = get_loss(params)
+        self.mse_loss = get_loss(params)
+
+    def __call__(self, prediction: torch.Tensor, target: torch.Tensor, *args):
+        if len(prediction) < 2:
+            image: torch.Tensor = args[0]
+            loss_seg = self.loss(prediction[0], target.squeeze(-1), self.params)
+            loss_reco = self.l1_loss(prediction[1], image[:, :1, ...], None)
+            loss_kld = self.kld_loss(prediction[2], prediction[3])
+            loss_cycle = self.mse_loss(prediction[2], prediction[4], None)
+            return 0.01 * loss_kld + loss_reco + 10 * loss_seg + loss_cycle
+        else:
+            return self.loss(prediction, target, self.params)
+
+
+class LossCalculatorDeepSupervision(AbstractLossCalculator):
+    def __init__(self, params):
+        super().__init__(params)
+        # This was taken from current Gandlf code, but I am not sure if
+        # we should have this set rigidly here, as it enforces the number of
+        # classes to be 4.
+        self.loss_weights = [0.5, 0.25, 0.175, 0.075]
+
+    def __call__(
+        self, prediction: torch.Tensor, target: torch.Tensor, *args
+    ) -> torch.Tensor:
+        loss_values = []
+        for i, pred in enumerate(prediction):
+            loss_values.append(
+                self.loss(pred, target[i], self.params) * self.loss_weights[i]
+            )
+        loss = torch.stack(loss_values).sum()
+        return loss
+
+
+class LossCalculatorSimple(AbstractLossCalculator):
+    def __call__(
+        self, prediction: torch.Tensor, target: torch.Tensor, *args
+    ) -> torch.Tensor:
+        return self.loss(prediction, target, self.params)
+
+
+class LossCalculatorFactory:
+    def __init__(self, params: dict):
+        self.params = params
+
+    def get_loss_calculator(self) -> AbstractLossCalculator:
+        if self.params["model"]["architecture"] == "sdnet":
+            return LossCalculatorSDNet(self.params)
+        elif "deep" in self.params["model"]["architecture"].lower():
+            return LossCalculatorDeepSupervision(self.params)
+        else:
+            return LossCalculatorSimple(self.params)

GANDLF/losses/segmentation.py

@@ -87,7 +87,8 @@ def generic_loss_calculator(
     accumulated_loss = 0
     # default to a ridiculous value so that it is ignored by default
     ignore_class = -1e10 if ignore_class is None else ignore_class
-
+    predicted = predicted.squeeze(-1)
+    target = target.squeeze(-1)
     for class_index in range(num_class):
         if class_index != ignore_class:
             current_loss = loss_criteria(
@@ -334,7 +335,7 @@ def FocalLoss(
             torch.Tensor: Computed focal loss for a single class.
         """
         ce_loss = torch.nn.CrossEntropyLoss(reduce=False)
-        logpt = ce_loss(preds, target)
+        logpt = ce_loss(preds.squeeze(-1), target.squeeze(-1))
         pt = torch.exp(-logpt)
         loss = ((1 - pt) ** gamma) * logpt
         return_loss = loss.sum()

GANDLF/metrics/__init__.py

@@ -1,6 +1,7 @@
 """
 All the metrics are to be called from here
 """
+from warnings import warn
 from typing import Union
 
 from GANDLF.losses.regression import MSE_loss, CEL
@@ -40,6 +41,7 @@ from .synthesis import (
 )
 import GANDLF.metrics.classification as classification
 import GANDLF.metrics.regression as regression
+from .segmentation_panoptica import generate_instance_segmentation
 
 
 # global defines for the metrics
@@ -100,6 +102,30 @@ surface_distance_ids = [
 ]
 
 
+def get_metrics(params: dict) -> dict:
+    """
+    Returns an dictionary of containing calculators of the specified metric functions
+
+    Args:
+        params (dict): A dictionary containing the overall training parameters.
+
+    Returns:
+        metric_calculators (dict): A dictionary containing the calculators of the specified metric functions.
+    """
+    metric_calculators = {}
+    for metric_name in params["metrics"]:
+        metric_name = metric_name.lower()
+        if metric_name not in global_metrics_dict:
+            warn(
+                f"Metric {metric_name} not found in global metrics dictionary, it will not be used.",
+                UserWarning,
+            )
+            continue
+        else:
+            metric_calculators[metric_name] = global_metrics_dict[metric_name]
+    return metric_calculators
+
+
 def overall_stats(predictions, ground_truth, params) -> dict[str, Union[float, list]]:
     """
     Generates a dictionary of metrics calculated on the overall predictions and ground truths.

GANDLF/metrics/generic.py

@@ -34,7 +34,7 @@ def generic_function_output_with_check(
         print(
             "WARNING: Negative values detected in prediction, cannot compute torchmetrics calculations."
         )
-        return torch.zeros((1), device=prediction.device)
+        return torch.tensor(0, device=prediction.device)
     else:
         # I need to do this with try-except, otherwise for binary problems it will
         # raise and error as the binary metrics do not have .num_classes