GANDLF 0.1.3.dev20250318__tar.gz → 0.1.4.dev20250502__tar.gz

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/Dockerfile-CPU

@@ -1,25 +1,35 @@
-FROM ubuntu:20.04
+FROM ubuntu:22.04
 LABEL github="https://github.com/mlcommons/GaNDLF"
 LABEL docs="https://mlcommons.github.io/GaNDLF/"
 LABEL version=1.0
+# ARG SETUPTOOLS_USE_DISTUTILS=local
+ARG DEBIAN_FRONTEND=noninteractive
 
 # Install fresh Python and dependencies for build-from-source
 RUN apt-get update && apt-get install -y software-properties-common
 RUN add-apt-repository ppa:deadsnakes/ppa
-RUN apt-get update &&  apt-get install -y  python3.9 python3-pip libjpeg8-dev zlib1g-dev python3-dev libpython3.9-dev libffi-dev libgl1
-RUN python3.9 -m pip install --upgrade pip==24.0
+RUN apt install -y python3.11 
+RUN apt install -y libpython3.11-dev 
+RUN apt install -y libpython3.11 
+# RUN apt install -y python-distutils-extra
+RUN apt install -y python3.11-venv 
+# RUN apt install -y python-setuptools
+RUN apt install -y python3-pip
+RUN apt-get install -y libjpeg8-dev zlib1g-dev libffi-dev libgl1
+# fix pip version because of weird PyYAML issue
+RUN python3.11 -m pip install --upgrade pip
 # EXPLICITLY install cpu versions of torch/torchvision (not all versions have +cpu modes on PyPI...)
-RUN python3.9 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cpu
-RUN python3.9 -m pip install openvino-dev==2023.0.1 opencv-python-headless mlcube_docker
+RUN python3.11 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cpu
+RUN python3.11 -m pip install openvino-dev opencv-python-headless
 
 # Do some dependency installation separately here to make layer caching more efficient
 COPY ./setup.py ./setup.py
-RUN python3.9 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
-    && python3.9 -m pip install -r ./requirements.txt
+RUN python3.11 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
+  && python3.11 -m pip install -r ./requirements.txt
 
 COPY . /GaNDLF
 WORKDIR /GaNDLF
-RUN python3.9 -m pip install -e .
+RUN python3.11 -m pip install -e .
 # Entrypoint forces all commands given via "docker run" to go through python, CMD forces the default entrypoint script argument to be gandlf run
 # If a user calls "docker run gandlf:[tag] anonymize", it will resolve to running "gandlf anonymize" instead.
 # CMD is inherently overridden by args to "docker run", entrypoint is constant.
@@ -31,7 +41,7 @@ CMD run
 # As a side benefit this also decreases the likelihood that users on a cluster won't be able to access their files.
 # See https://github.com/hexops/dockerfile as a best practices guide.
 #RUN addgroup --gid 10001 --system nonroot \
-# && adduser  --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
+# && adduser --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
 #
 #USER nonroot
 

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/Dockerfile-CUDA11.8

@@ -1,28 +1,37 @@
-FROM nvidia/cuda:11.8.0-devel-ubuntu20.04
+FROM nvidia/cuda:11.8.0-devel-ubuntu22.04
 LABEL github="https://github.com/mlcommons/GaNDLF"
 LABEL docs="https://mlcommons.github.io/GaNDLF/"
 LABEL version=1.0
+# ARG SETUPTOOLS_USE_DISTUTILS=local
 
 # Install instructions for NVIDIA Container Toolkit allowing you to use the host's GPU: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html
 # Note that to do this on a Windows host you need experimental feature "CUDA on WSL" -- not yet stable.
 ENV DEBIAN_FRONTEND=noninteractive 
 
-# Explicitly install python3.9 (this uses 11.1 for now, as PyTorch LTS 1.8.2 is built against it)
+# Explicitly install python3.11 (this uses 11.1 for now, as PyTorch LTS 1.8.2 is built against it)
 RUN apt-get update && apt-get install -y software-properties-common
 RUN add-apt-repository ppa:deadsnakes/ppa
-RUN apt-get update &&  apt-get install -y  python3.9 python3-pip libjpeg8-dev zlib1g-dev python3-dev libpython3.9-dev libffi-dev libgl1
-RUN python3.9 -m pip install --upgrade pip==24.0
-RUN python3.9 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cu118
-RUN python3.9 -m pip install openvino-dev==2023.0.1 opencv-python-headless mlcube_docker
+RUN apt install -y python3.11 
+RUN apt install -y libpython3.11-dev 
+RUN apt install -y libpython3.11 
+# RUN apt install -y python-distutils-extra
+RUN apt install -y python3.11-venv 
+# RUN apt install -y python-setuptools
+RUN apt install -y python3-pip 
+RUN apt-get install -y libjpeg8-dev zlib1g-dev libffi-dev libgl1
+# fix pip version because of weird PyYAML issue
+RUN python3.11 -m pip install --upgrade pip
+RUN python3.11 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cu118
+RUN python3.11 -m pip install openvino-dev opencv-python-headless
 
 # Do some dependency installation separately here to make layer caching more efficient
 COPY ./setup.py ./setup.py
-RUN python3.9 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
-    && python3.9 -m pip install -r ./requirements.txt
+RUN python3.11 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
+  && python3.11 -m pip install -r ./requirements.txt
 
 COPY . /GaNDLF
 WORKDIR /GaNDLF
-RUN python3.9 -m pip install -e .
+RUN python3.11 -m pip install -e .
 
 # Entrypoint forces all commands given via "docker run" to go through python, CMD forces the default entrypoint script argument to be gandlf run
 # If a user calls "docker run gandlf:[tag] anonymize", it will resolve to running "gandlf anonymize" instead.
@@ -35,7 +44,7 @@ CMD run
 # As a side benefit this also decreases the likelihood that users on a cluster won't be able to access their files.
 # See https://github.com/hexops/dockerfile as a best practices guide.
 #RUN addgroup --gid 10001 --system nonroot \
-# && adduser  --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
+# && adduser --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
 
 #USER nonroot
 

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/Dockerfile-CUDA12.1

@@ -1,28 +1,37 @@
-FROM nvidia/cuda:12.1.0-devel-ubuntu20.04
+FROM nvidia/cuda:12.1.0-devel-ubuntu22.04
 LABEL github="https://github.com/mlcommons/GaNDLF"
 LABEL docs="https://mlcommons.github.io/GaNDLF/"
 LABEL version=1.0
+# ARG SETUPTOOLS_USE_DISTUTILS=local
 
 # Install instructions for NVIDIA Container Toolkit allowing you to use the host's GPU: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html
 # Note that to do this on a Windows host you need experimental feature "CUDA on WSL" -- not yet stable.
 ENV DEBIAN_FRONTEND=noninteractive 
 
-# Explicitly install python3.9 (this uses 11.1 for now, as PyTorch LTS 1.8.2 is built against it)
+# Explicitly install python3.11 (this uses 11.1 for now, as PyTorch LTS 1.8.2 is built against it)
 RUN apt-get update && apt-get install -y software-properties-common
 RUN add-apt-repository ppa:deadsnakes/ppa
-RUN apt-get update &&  apt-get install -y  python3.9 python3-pip libjpeg8-dev zlib1g-dev python3-dev libpython3.9-dev libffi-dev libgl1
-RUN python3.9 -m pip install --upgrade pip==24.0
-RUN python3.9 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cu121
-RUN python3.9 -m pip install openvino-dev==2023.0.1 opencv-python-headless mlcube_docker
+RUN apt install -y python3.11 
+RUN apt install -y libpython3.11-dev 
+RUN apt install -y libpython3.11 
+# RUN apt install -y python-distutils-extra
+RUN apt install -y python3.11-venv 
+# RUN apt install -y python-setuptools
+RUN apt install -y python3-pip 
+RUN apt-get install -y libjpeg8-dev zlib1g-dev libffi-dev libgl1
+# fix pip version because of weird PyYAML issue
+RUN python3.11 -m pip install --upgrade pip
+RUN python3.11 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/cu121
+RUN python3.11 -m pip install openvino-dev opencv-python-headless
 
 # Do some dependency installation separately here to make layer caching more efficient
 COPY ./setup.py ./setup.py
-RUN python3.9 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
-    && python3.9 -m pip install -r ./requirements.txt
+RUN python3.11 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
+  && python3.11 -m pip install -r ./requirements.txt
 
 COPY . /GaNDLF
 WORKDIR /GaNDLF
-RUN python3.9 -m pip install -e .
+RUN python3.11 -m pip install -e .
 
 # Entrypoint forces all commands given via "docker run" to go through python, CMD forces the default entrypoint script argument to be gandlf run
 # If a user calls "docker run gandlf:[tag] anonymize", it will resolve to running "gandlf anonymize" instead.
@@ -35,7 +44,7 @@ CMD run
 # As a side benefit this also decreases the likelihood that users on a cluster won't be able to access their files.
 # See https://github.com/hexops/dockerfile as a best practices guide.
 #RUN addgroup --gid 10001 --system nonroot \
-# && adduser  --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
+# && adduser --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
 
 #USER nonroot
 

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/Dockerfile-ROCm

@@ -1,27 +1,35 @@
-FROM rocm/pytorch:rocm6.1_ubuntu20.04_py3.9_pytorch
+FROM rocm/pytorch:rocm6.1_ubuntu22.04_py3.10_pytorch_2.4
 LABEL github="https://github.com/mlcommons/GaNDLF"
 LABEL docs="https://mlcommons.github.io/GaNDLF/"
 LABEL version=1.0
+# ARG SETUPTOOLS_USE_DISTUTILS=local
 
 # Quick start instructions on using Docker with ROCm: https://github.com/RadeonOpenCompute/ROCm-docker/blob/master/quick-start.md
 
 # The base image contains ROCm, python 3.9 and pytorch already, no need to install those
 RUN apt-get update && apt-get install -y software-properties-common
 RUN add-apt-repository ppa:deadsnakes/ppa
-RUN apt-get update &&  apt-get install -y  python3.9 python3-pip libjpeg8-dev zlib1g-dev python3-dev libpython3.9-dev libffi-dev libgl1
-RUN python3.9 -m pip install --upgrade pip==24.0
-RUN python3.9 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/rocm6.0
-RUN python3.9 -m pip install --upgrade pip && python3.9 -m pip install openvino-dev==2023.0.1 opencv-python-headless mlcube_docker
-RUN apt-get update && apt-get install -y libgl1
+RUN apt install -y python3.11 
+RUN apt install -y libpython3.11-dev 
+RUN apt install -y libpython3.11 
+# RUN apt install -y python-distutils-extra
+RUN apt install -y python3.11-venv 
+# RUN apt install -y python-setuptools
+RUN apt install -y python3-pip 
+RUN apt-get install -y python3.11 python3-pip libjpeg8-dev zlib1g-dev python3-dev libpython3.11-dev libffi-dev libgl1
+# fix pip version because of weird PyYAML issue
+RUN python3.11 -m pip install --upgrade pip
+RUN python3.11 -m pip install torch==2.5.0 torchvision==0.20.0 torchaudio==2.5.0 --index-url https://download.pytorch.org/whl/rocm6.1
+RUN python3.11 -m pip install openvino-dev opencv-python-headless
 
 # Do some dependency installation separately here to make layer caching more efficient
 COPY ./setup.py ./setup.py
-RUN python3.9 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
-    && python3.9 -m pip install -r ./requirements.txt
+RUN python3.11 -c "from setup import requirements; file = open('requirements.txt', 'w'); file.writelines([req + '\n' for req in requirements]); file.close()" \
+  && python3.11 -m pip install -r ./requirements.txt
 
 COPY . /GaNDLF
 WORKDIR /GaNDLF
-RUN python3.9 -m pip install -e .
+RUN python3.11 -m pip install -e .
 
 # Entrypoint forces all commands given via "docker run" to go through python, CMD forces the default entrypoint script argument to be gandlf run
 # If a user calls "docker run gandlf:[tag] anonymize", it will resolve to running "gandlf anonymize" instead.
@@ -35,7 +43,7 @@ CMD run
 # As a side benefit this also decreases the likelihood that users on a cluster won't be able to access their files.
 # See https://github.com/hexops/dockerfile as a best practices guide.
 #RUN addgroup --gid 10001 --system nonroot \
-# && adduser  --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
+# && adduser --uid 10000 --system --ingroup nonroot --home /home/nonroot nonroot
 #
 #USER nonroot
 

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/cli/deploy.py

@@ -246,7 +246,7 @@ def get_metrics_mlcube_config(
         mlcube_config = yaml.safe_load(f)
     if entrypoint_script:
         # modify the entrypoint to run a custom script
-        mlcube_config["tasks"]["evaluate"]["entrypoint"] = "python3.9 /entrypoint.py"
+        mlcube_config["tasks"]["evaluate"]["entrypoint"] = "python3.11 /entrypoint.py"
     mlcube_config["docker"]["build_strategy"] = "auto"
     return mlcube_config
 
@@ -315,7 +315,7 @@ def get_model_mlcube_config(
         device = "cuda" if requires_gpu else "cpu"
         mlcube_config["tasks"]["infer"][
             "entrypoint"
-        ] = f"python3.9 /entrypoint.py --device {device}"
+        ] = f"python3.11 /entrypoint.py --device {device}"
 
     return mlcube_config
     # Duplicate training task into one from reset (must be explicit) and one that resumes with new data

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/cli/generate_metrics.py

@@ -20,6 +20,7 @@ from GANDLF.metrics import (
     mean_squared_log_error,
     mean_absolute_error,
     ncc_metrics,
+    generate_instance_segmentation,
 )
 from GANDLF.losses.segmentation import dice
 from GANDLF.metrics.segmentation import (
@@ -259,6 +260,26 @@ def generate_metrics_dict(
                     "volumeSimilarity_" + str(class_index)
                 ] = label_overlap_filter.GetVolumeSimilarity()
 
+    elif problem_type == "segmentation_brats":
+        for _, row in tqdm(input_df.iterrows(), total=input_df.shape[0]):
+            current_subject_id = row["SubjectID"]
+            overall_stats_dict[current_subject_id] = {}
+            label_image = torchio.LabelMap(row["Target"])
+            pred_image = torchio.LabelMap(row["Prediction"])
+            label_tensor = label_image.data
+            pred_tensor = pred_image.data
+            spacing = label_image.spacing
+            if label_tensor.data.shape[-1] == 1:
+                spacing = spacing[0:2]
+            # add dimension for batch
+            parameters["subject_spacing"] = torch.Tensor(spacing).unsqueeze(0)
+            label_array = label_tensor.unsqueeze(0).numpy()
+            pred_array = pred_tensor.unsqueeze(0).numpy()
+
+            overall_stats_dict[current_subject_id] = generate_instance_segmentation(
+                prediction=pred_array, target=label_array
+            )
+
     elif problem_type == "synthesis":
 
         def __fix_2d_tensor(input_tensor):

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/cli/main_run.py

@@ -16,10 +16,9 @@ def main_run(
     config_file: str,
     model_dir: str,
     train_mode: bool,
-    device: str,
     resume: bool,
     reset: bool,
-    _profile: Optional[bool] = False,
+    profile: Optional[bool] = False,
     output_dir: Optional[str] = None,
 ) -> None:
     """
@@ -30,9 +29,9 @@ def main_run(
         config_file (str): The YAML file of the training configuration.
         model_dir (str): The model directory; for training, model is written out here, and for inference, trained model is expected here.
         train_mode (bool): Whether to train or infer.
-        device (str): The device type.
         resume (bool): Whether the previous run will be resumed or not.
         reset (bool): Whether the previous run will be reset or not.
+        profile (bool): Whether to profile the training or not. Defaults to False.
         output_dir (str): The output directory for the inference session. Defaults to None.
 
     Returns:
@@ -40,9 +39,7 @@ def main_run(
     """
     file_data_full = data_csv
     model_parameters = config_file
-    device = device
     parameters = ConfigManager(model_parameters)
-    parameters["device_id"] = -1
 
     if train_mode:
         if resume:
@@ -60,9 +57,6 @@ def main_run(
         parameters["output_dir"] = model_dir
     Path(parameters["output_dir"]).mkdir(parents=True, exist_ok=True)
 
-    if "-1" in device:
-        device = "cpu"
-
     # parse training CSV
     if "," in file_data_full:
         # training and validation pre-split
@@ -96,10 +90,9 @@ def main_run(
                 dataframe_testing=data_testing,
                 outputDir=parameters["output_dir"],
                 parameters=parameters,
-                device=device,
                 resume=resume,
                 reset=reset,
-                _profile=_profile,
+                profile=profile,
             )
     else:
         data_full, headers = parseTrainingCSV(file_data_full, train=train_mode)
@@ -109,9 +102,9 @@ def main_run(
                 dataframe=data_full,
                 outputDir=parameters["output_dir"],
                 parameters=parameters,
-                device=device,
                 resume=resume,
                 reset=reset,
+                profile=profile,
             )
         else:
             _, data_full, headers = parseTestingCSV(
@@ -122,5 +115,4 @@ def main_run(
                 modelDir=model_dir,
                 outputDir=output_dir,
                 parameters=parameters,
-                device=device,
             )

gandlf-0.1.4.dev20250502/GANDLF/compute/__init__.py

@@ -0,0 +1 @@
+from .generic import create_pytorch_objects

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/compute/forward_pass.py

@@ -150,7 +150,6 @@ def validate_network(
                 tensor=subject[key]["data"].squeeze(0),
                 affine=subject[key]["affine"].squeeze(0),
             )
-
         # regression/classification problem AND label is present
         if (params["problem_type"] != "segmentation") and label_present:
             sampler = torchio.data.LabelSampler(params["patch_size"])

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/compute/generic.py

@@ -2,17 +2,122 @@ from typing import Optional, Tuple
 from pandas.util import hash_pandas_object
 import torch
 from torch.utils.data import DataLoader
-
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
 from GANDLF.models import get_model
 from GANDLF.schedulers import get_scheduler
 from GANDLF.optimizers import get_optimizer
-from GANDLF.data import get_train_loader, get_validation_loader
+from GANDLF.data import get_train_loader, get_validation_loader, ImagesFromDataFrame
 from GANDLF.utils import (
     populate_header_in_parameters,
+    populate_channel_keys_in_params,
     parseTrainingCSV,
     send_model_to_device,
     get_class_imbalance_weights,
 )
+from GANDLF.utils.write_parse import get_dataframe
+from torchio import SubjectsDataset, Queue
+from typing import Union
+
+
+@dataclass
+class AbstractSubsetDataParser(ABC):
+    """
+    Interface for subset data parsers, needed to separate the dataset creation
+    from construction of the dataloaders.
+    """
+
+    subset_csv_path: str
+    parameters_dict: dict
+
+    @abstractmethod
+    def create_subset_dataset(self) -> Union[SubjectsDataset, Queue]:
+        """
+        Method to create the subset dataset based on the subset CSV file
+        and the parameters dict.
+
+        Returns:
+            Union[SubjectsDataset, Queue]: The subset dataset.
+        """
+        pass
+
+    def get_params_extended_with_subset_data(self) -> dict:
+        """
+        Trick to get around the fact that parameters dict need to be modified
+        during this parsing procedure. This method should be called after
+        create_subset_dataset(), as this method will populate the parameters
+        dict with the headers from the subset data.
+        """
+        return self.parameters_dict
+
+
+class TrainingSubsetDataParser(AbstractSubsetDataParser):
+    def create_subset_dataset(self) -> Union[SubjectsDataset, Queue]:
+        (
+            self.parameters_dict["training_data"],
+            headers_to_populate_train,
+        ) = parseTrainingCSV(self.subset_csv_path, train=True)
+
+        self.parameters_dict = populate_header_in_parameters(
+            self.parameters_dict, headers_to_populate_train
+        )
+
+        (
+            self.parameters_dict["penalty_weights"],
+            self.parameters_dict["sampling_weights"],
+            self.parameters_dict["class_weights"],
+        ) = get_class_imbalance_weights(
+            self.parameters_dict["training_data"], self.parameters_dict
+        )
+
+        print("Penalty weights : ", self.parameters_dict["penalty_weights"])
+        print("Sampling weights: ", self.parameters_dict["sampling_weights"])
+        print("Class weights   : ", self.parameters_dict["class_weights"])
+
+        return ImagesFromDataFrame(
+            get_dataframe(self.parameters_dict["training_data"]),
+            self.parameters_dict,
+            train=True,
+            loader_type="train",
+        )
+
+
+class ValidationSubsetDataParser(AbstractSubsetDataParser):
+    def create_subset_dataset(self) -> Union[SubjectsDataset, Queue]:
+        (self.parameters_dict["validation_data"], _) = parseTrainingCSV(
+            self.subset_csv_path, train=False
+        )
+        validation_dataset = ImagesFromDataFrame(
+            get_dataframe(self.parameters_dict["validation_data"]),
+            self.parameters_dict,
+            train=False,
+            loader_type="validation",
+        )
+        self.parameters_dict = populate_channel_keys_in_params(
+            validation_dataset, self.parameters_dict
+        )
+        return validation_dataset
+
+
+class TestSubsetDataParser(AbstractSubsetDataParser):
+    def create_subset_dataset(self) -> Union[SubjectsDataset, Queue]:
+        testing_dataset = ImagesFromDataFrame(
+            get_dataframe(self.subset_csv_path),
+            self.parameters_dict,
+            train=False,
+            loader_type="testing",
+        )
+        if not ("channel_keys" in self.parameters_dict):
+            self.parameters_dict = populate_channel_keys_in_params(
+                testing_dataset, self.parameters_dict
+            )
+        return testing_dataset
+
+
+class InferenceSubsetDataParserRadiology(TestSubsetDataParser):
+    """Simple wrapper for name coherency, functionally this is the same as TestSubsetDataParser"""
+
+    pass
 
 
 def create_pytorch_objects(

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/compute/inference_loop.py

@@ -18,8 +18,8 @@ from torch.cuda.amp import autocast
 import openslide
 from GANDLF.data import get_testing_loader
 from GANDLF.utils import (
-    best_model_path_end,
-    latest_model_path_end,
+    BEST_MODEL_PATH_END,
+    LATEST_MODEL_PATH_END,
     load_ov_model,
     print_model_summary,
     applyCustomColorMap,
@@ -72,11 +72,11 @@ def inference_loop(
             files_to_check = [
                 os.path.join(
                     modelDir,
-                    str(parameters["model"]["architecture"]) + best_model_path_end,
+                    str(parameters["model"]["architecture"]) + BEST_MODEL_PATH_END,
                 ),
                 os.path.join(
                     modelDir,
-                    str(parameters["model"]["architecture"]) + latest_model_path_end,
+                    str(parameters["model"]["architecture"]) + LATEST_MODEL_PATH_END,
                 ),
             ]
 

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/compute/loss_and_metric.py

@@ -1,4 +1,3 @@
-import sys
 import warnings
 from typing import Dict, Tuple, Union
 from GANDLF.losses import global_losses_dict
@@ -134,7 +133,7 @@ def get_loss_and_metrics(
     # Metrics should be a list
     for metric in params["metrics"]:
         metric_lower = metric.lower()
-        metric_output[metric] = 0
+        metric_output[metric] = 0.0
         if metric_lower not in global_metrics_dict:
             warnings.warn("WARNING: Could not find the requested metric '" + metric)
             continue

{gandlf-0.1.3.dev20250318 → gandlf-0.1.4.dev20250502}/GANDLF/compute/training_loop.py

@@ -13,9 +13,9 @@ from GANDLF.grad_clipping.grad_scaler import GradScaler, model_parameters_exclud
 from GANDLF.grad_clipping.clip_gradients import dispatch_clip_grad_
 from GANDLF.utils import (
     get_date_time,
-    best_model_path_end,
-    latest_model_path_end,
-    initial_model_path_end,
+    BEST_MODEL_PATH_END,
+    LATEST_MODEL_PATH_END,
+    INITIAL_MODEL_PATH_END,
     save_model,
     optimize_and_save_model,
     load_model,
@@ -281,13 +281,13 @@ def training_loop(
     first_model_saved = False
     model_paths = {
         "best": os.path.join(
-            output_dir, params["model"]["architecture"] + best_model_path_end
+            output_dir, params["model"]["architecture"] + BEST_MODEL_PATH_END
         ),
         "initial": os.path.join(
-            output_dir, params["model"]["architecture"] + initial_model_path_end
+            output_dir, params["model"]["architecture"] + INITIAL_MODEL_PATH_END
         ),
         "latest": os.path.join(
-            output_dir, params["model"]["architecture"] + latest_model_path_end
+            output_dir, params["model"]["architecture"] + LATEST_MODEL_PATH_END
         ),
     }
 
@@ -481,14 +481,14 @@ def training_loop(
                 + str(mem[3])
             )
             if params["device"] == "cuda":
-                mem_cuda = torch.cuda.memory_stats()
+                cuda_memory_stats = torch.cuda.memory_stats()
                 outputToWrite_mem += (
                     ","
-                    + str(mem_cuda["active.all.peak"])
+                    + str(cuda_memory_stats["active.all.peak"])
                     + ","
-                    + str(mem_cuda["active.all.current"])
+                    + str(cuda_memory_stats["active.all.current"])
                     + ","
-                    + str(mem_cuda["active.all.allocated"])
+                    + str(cuda_memory_stats["active.all.allocated"])
                 )
             outputToWrite_mem += ",\n"
             file_mem.write(outputToWrite_mem)

gandlf-0.1.4.dev20250502/GANDLF/config_manager.py

@@ -0,0 +1,69 @@
+import traceback
+from typing import Union
+import yaml
+from pydantic import ValidationError
+
+from GANDLF.configuration.parameters_config import Parameters
+from GANDLF.configuration.exclude_parameters import exclude_parameters
+from GANDLF.configuration.utils import handle_configuration_errors
+
+
+def _parseConfig(
+    config_file_path: Union[str, dict], version_check_flag: bool = True
+) -> None:
+    """
+    This function parses the configuration file and returns a dictionary of parameters.
+
+    Args:
+        config_file_path (Union[str, dict]): The filename of the configuration file.
+        version_check_flag (bool, optional): Whether to check the version in configuration file. Defaults to True.
+
+    Returns:
+        dict: The parameter dictionary.
+    """
+    params = config_file_path
+    if not isinstance(config_file_path, dict):
+        params = yaml.safe_load(open(config_file_path, "r"))
+
+    return params
+
+
+def ConfigManager(
+    config_file_path: Union[str, dict], version_check_flag: bool = True
+) -> dict:
+    """
+    This function parses the configuration file and returns a dictionary of parameters.
+
+    Args:
+        config_file_path (Union[str, dict]): The filename of the configuration file.
+        version_check_flag (bool, optional): Whether to check the version in configuration file. Defaults to True.
+
+    Returns:
+        dict: The parameter dictionary.
+    """
+    try:
+        parameters_config = Parameters(
+            **_parseConfig(config_file_path, version_check_flag)
+        )
+        parameters = parameters_config.model_dump(
+            exclude={
+                field
+                for field in exclude_parameters
+                if getattr(parameters_config, field) is None
+            }
+        )
+        return parameters
+
+    except Exception as e:
+        if isinstance(e, ValidationError):
+            handle_configuration_errors(e)
+            raise
+        ## todo: ensure logging captures assertion errors
+        else:
+            assert (
+                False
+            ), f"Config parsing failed: {config_file_path=}, {version_check_flag=}, Exception: {str(e)}, {traceback.format_exc()}"
+        # logging.error(
+        #     f"gandlf config parsing failed: {config_file_path=}, {version_check_flag=}, Exception: {str(e)}, {traceback.format_exc()}"
+        # )
+        # raise