Upgrade base pandas version

GANDLF/cli/generate_metrics.py

@@ -47,7 +47,7 @@ def generate_metrics_dict(input_csv: str, config: str, outputfile: str = None) -
     # check required headers in a case insensitive manner
     headers = {}
     required_columns = ["subjectid", "prediction", "target"]
-    for col, _ in input_df.iteritems():
+    for col, _ in input_df.items():
         col_lower = col.lower()
         for column_to_check in required_columns:
             if column_to_check == col_lower:
@@ -194,7 +194,13 @@ def __fix_2d_tensor(input_tensor):
             else:
                 return input_tensor
 
-        def __percentile_clip(input_tensor, reference_tensor=None, p_min=0.5, p_max=99.5, strictlyPositive=True):
+        def __percentile_clip(
+            input_tensor,
+            reference_tensor=None,
+            p_min=0.5,
+            p_max=99.5,
+            strictlyPositive=True,
+        ):
             """Normalizes a tensor based on percentiles. Clips values below and above the percentile.
             Percentiles for normalization can come from another tensor.
 
@@ -209,13 +215,21 @@ def __percentile_clip(input_tensor, reference_tensor=None, p_min=0.5, p_max=99.5
             Returns:
                 torch.Tensor: The input_tensor normalized based on the percentiles of the reference tensor.
             """
-            reference_tensor = input_tensor if reference_tensor is None else reference_tensor
-            v_min, v_max = np.percentile(reference_tensor, [p_min,p_max]) #get p_min percentile and p_max percentile
+            reference_tensor = (
+                input_tensor if reference_tensor is None else reference_tensor
+            )
+            v_min, v_max = np.percentile(
+                reference_tensor, [p_min, p_max]
+            )  # get p_min percentile and p_max percentile
 
             # set lower bound to be 0 if strictlyPositive is enabled
             v_min = max(v_min, 0.0) if strictlyPositive else v_min
-            output_tensor = np.clip(input_tensor,v_min,v_max) #clip values to percentiles from reference_tensor
-            output_tensor = (output_tensor - v_min)/(v_max-v_min) #normalizes values to [0;1]
+            output_tensor = np.clip(
+                input_tensor, v_min, v_max
+            )  # clip values to percentiles from reference_tensor
+            output_tensor = (output_tensor - v_min) / (
+                v_max - v_min
+            )  # normalizes values to [0;1]
             return output_tensor
 
         for _, row in tqdm(input_df.iterrows(), total=input_df.shape[0]):
@@ -244,9 +258,23 @@ def __percentile_clip(input_tensor, reference_tensor=None, p_min=0.5, p_max=99.5
             # Normalize to [0;1] based on GT (otherwise MSE will depend on the image intensity range)
             normalize = parameters.get("normalize", True)
             if normalize:
-                reference_tensor = target_image * ~mask #use all the tissue that is not masked for normalization
-                gt_image_infill = __percentile_clip(gt_image_infill, reference_tensor=reference_tensor, p_min=0.5, p_max=99.5, strictlyPositive=True)
-                output_infill = __percentile_clip(output_infill, reference_tensor=reference_tensor, p_min=0.5, p_max=99.5, strictlyPositive=True)
+                reference_tensor = (
+                    target_image * ~mask
+                )  # use all the tissue that is not masked for normalization
+                gt_image_infill = __percentile_clip(
+                    gt_image_infill,
+                    reference_tensor=reference_tensor,
+                    p_min=0.5,
+                    p_max=99.5,
+                    strictlyPositive=True,
+                )
+                output_infill = __percentile_clip(
+                    output_infill,
+                    reference_tensor=reference_tensor,
+                    p_min=0.5,
+                    p_max=99.5,
+                    strictlyPositive=True,
+                )
 
             overall_stats_dict[current_subject_id][
                 "ssim"
@@ -303,14 +331,17 @@ def __percentile_clip(input_tensor, reference_tensor=None, p_min=0.5, p_max=99.5
                 overall_stats_dict[current_subject_id][
                     "psnr_01"
                 ] = peak_signal_noise_ratio(
-                    gt_image_infill, output_infill, data_range=(0,1)
+                    gt_image_infill, output_infill, data_range=(0, 1)
                 ).item()
 
                 # same as above but with epsilon for robustness
                 overall_stats_dict[current_subject_id][
                     "psnr_01_eps"
                 ] = peak_signal_noise_ratio(
-                    gt_image_infill, output_infill, data_range=(0,1), epsilon=sys.float_info.epsilon
+                    gt_image_infill,
+                    output_infill,
+                    data_range=(0, 1),
+                    epsilon=sys.float_info.epsilon,
                 ).item()
 
     pprint(overall_stats_dict)

GANDLF/cli/patch_extraction.py

@@ -82,7 +82,7 @@ def patch_extraction(input_path, output_path, config=None):
         manager.set_valid_mask(mask, scale)
         # Reject patch if any pixels are transparent
         manager.add_patch_criteria(alpha_rgb_2d_channel_check)
-        #manager.add_patch_criteria(pen_marking_check) ### will be added to main code after rigourous experimentation
+        # manager.add_patch_criteria(pen_marking_check) ### will be added to main code after rigourous experimentation
         manager.add_patch_criteria(patch_artifact_check)
         # Reject patch if image dimensions are not equal to PATCH_SIZE
         patch_dims_check = partial(

GANDLF/logger.py

@@ -34,7 +34,9 @@ def write_header(self, mode="train"):
         if os.stat(self.filename).st_size == 0:
             mode_lower = mode.lower()
             row = "epoch_no," + mode_lower + "_loss,"
-            row += ",".join([mode_lower + "_" + metric for metric in self.metrics]) + ","
+            row += (
+                ",".join([mode_lower + "_" + metric for metric in self.metrics]) + ","
+            )
             row = row[:-1]
             row += "\n"
             self.csv.write(row)

GANDLF/metrics/synthesis.py

@@ -48,7 +48,9 @@ def mean_squared_error(target, prediction) -> torch.Tensor:
     return mse(preds=prediction, target=target)
 
 
-def peak_signal_noise_ratio(target, prediction, data_range=None, epsilon=None) -> torch.Tensor:
+def peak_signal_noise_ratio(
+    target, prediction, data_range=None, epsilon=None
+) -> torch.Tensor:
     """
     Computes the peak signal to noise ratio between the target and prediction.
 
@@ -60,16 +62,22 @@ def peak_signal_noise_ratio(target, prediction, data_range=None, epsilon=None) -
     """
 
     if epsilon == None:
-        psnr = PeakSignalNoiseRatio() if data_range == None else PeakSignalNoiseRatio(data_range=data_range[1]-data_range[0])
+        psnr = (
+            PeakSignalNoiseRatio()
+            if data_range == None
+            else PeakSignalNoiseRatio(data_range=data_range[1] - data_range[0])
+        )
         return psnr(preds=prediction, target=target)
-    else: # implementation of PSNR that does not give 'inf'/'nan' when 'mse==0'
+    else:  # implementation of PSNR that does not give 'inf'/'nan' when 'mse==0'
         mse = mean_squared_error(target, prediction)
-        if data_range == None: #compute data_range like torchmetrics if not given
-            min_v = 0 if torch.min(target) > 0 else torch.min(target) #look at this line
+        if data_range == None:  # compute data_range like torchmetrics if not given
+            min_v = (
+                0 if torch.min(target) > 0 else torch.min(target)
+            )  # look at this line
             max_v = torch.max(target)
         else:
             min_v, max_v = data_range
-        return 10.0 * torch.log10(((max_v-min_v) ** 2) / (mse + epsilon))
+        return 10.0 * torch.log10(((max_v - min_v) ** 2) / (mse + epsilon))
 
 
 def mean_squared_log_error(target, prediction) -> torch.Tensor:

GANDLF/models/brain_age.py

@@ -3,6 +3,7 @@
 import torchvision
 import traceback
 
+
 def brainage(parameters):
     """
     This function creates a VGG16-based neural network model for brain age prediction.
@@ -18,7 +19,9 @@ def brainage(parameters):
     """
 
     # Check that the input data is 2D
-    assert parameters["model"]["dimension"] == 2, "Brain Age predictions only work on 2D data"
+    assert (
+        parameters["model"]["dimension"] == 2
+    ), "Brain Age predictions only work on 2D data"
 
     try:
         # Load the pretrained VGG16 model
@@ -38,13 +41,19 @@ def brainage(parameters):
     features = list(model.classifier.children())[:-1]  # Remove the last layer
     features.extend(
         [
-            nn.Linear(num_features, 1024),  # Add a linear layer with 1024 output features
+            nn.Linear(
+                num_features, 1024
+            ),  # Add a linear layer with 1024 output features
             nn.ReLU(True),  # Add a ReLU activation function
             nn.Dropout2d(0.8),  # Add a 2D dropout layer with a probability of 0.8
-            nn.Linear(1024, 1),  # Add a linear layer with 1 output feature (for brain age prediction)
+            nn.Linear(
+                1024, 1
+            ),  # Add a linear layer with 1 output feature (for brain age prediction)
         ]
     )
-    model.classifier = nn.Sequential(*features)  # Replace the model classifier with the modified one
+    model.classifier = nn.Sequential(
+        *features
+    )  # Replace the model classifier with the modified one
 
     # Set the "amp" parameter to False (not yet implemented for VGG)
     parameters["model"]["amp"] = False

GANDLF/training_manager.py

@@ -93,7 +93,7 @@ def TrainingManager(dataframe, outputDir, parameters, device, resume, reset):
         else:
             # loop over all trainAndVal_index and construct new dataframe
             for subject_idx in trainAndVal_index:
-                trainingAndValidationData = trainingAndValidationData.append(
+                trainingAndValidationData = trainingAndValidationData._append(
                     trainingData_full[
                         trainingData_full[
                             trainingData_full.columns[
@@ -106,7 +106,7 @@ def TrainingManager(dataframe, outputDir, parameters, device, resume, reset):
 
             # loop over all testing_index and construct new dataframe
             for subject_idx in testing_index:
-                testingData = testingData.append(
+                testingData = testingData._append(
                     trainingData_full[
                         trainingData_full[
                             trainingData_full.columns[
@@ -199,7 +199,7 @@ def TrainingManager(dataframe, outputDir, parameters, device, resume, reset):
 
             # loop over all train_index and construct new dataframe
             for subject_idx in train_index:
-                trainingData = trainingData.append(
+                trainingData = trainingData._append(
                     trainingData_full[
                         trainingData_full[
                             trainingData_full.columns[
@@ -212,7 +212,7 @@ def TrainingManager(dataframe, outputDir, parameters, device, resume, reset):
 
             # loop over all val_index and construct new dataframe
             for subject_idx in val_index:
-                validationData = validationData.append(
+                validationData = validationData._append(
                     trainingData_full[
                         trainingData_full[
                             trainingData_full.columns[

GANDLF/utils/write_parse.py

@@ -22,7 +22,9 @@ def writeTrainingCSV(
     channelsID_list = channelsID.split(",")  # split into list
 
     outputToWrite = "SubjectID,"
-    outputToWrite += ",".join(["Channel_" + str(i) for i, n in enumerate(channelsID_list)]) + ","
+    outputToWrite += (
+        ",".join(["Channel_" + str(i) for i, n in enumerate(channelsID_list)]) + ","
+    )
     if labelID is not None:
         outputToWrite += "Label"
     outputToWrite += "\n"

setup.py

@@ -84,7 +84,7 @@ def run(self):
     "torchvision",
     "tqdm",
     "torchio==0.18.75",
-    "pandas<2.0.0",
+    "pandas>=2.0.0",
     "scikit-learn>=0.23.2",
     "scikit-image>=0.19.1",
     "setuptools",
@@ -119,7 +119,7 @@ def run(self):
         version=__version__,
         author="MLCommons",
         author_email="gandlf@mlcommons.org",
-        python_requires=">=3.9, <=3.10",
+        python_requires=">=3.9, <3.11",
         packages=find_packages(
             where=os.path.dirname(os.path.abspath(__file__)),
             exclude=toplevel_package_excludes,