import os import pandas as pd import torch from torch.utils.data import Dataset from PIL import Image from utils.labels import Condition from config.biomarker_config import FlexibleBiomarkerConfig class ClassifierDataset(Dataset): """ Load images and corresponding labels for """ def __init__(self, data_path, biomarker_config, transforms=None, size=256, train=True, csv_file=None): """ Initialize data set Loads and preprocesses data @param data_path : path to data and labels @param biomarker_config : FlexibleBiomarkerConfig object specifying which biomarkers to use @param size : size of each xray @param train : load train or test dataset """ if not os.path.exists(data_path): raise IOError('Path given for ClassifierDataset {} does not exist...'.format(data_path)) self.data_path = data_path self.size = size self.biomarker_config = biomarker_config csv_name = csv_file if csv_file is not None else ('train.csv' if train else 'val.csv') self.df = pd.read_csv(os.path.join(data_path, csv_name)) # Apply age filtering for HIPAA compliance self.df = self._filter_age_records() self.transforms = transforms # Get tensor layout for efficient indexing self.tensor_layout = self.biomarker_config.get_tensor_layout() # Pre-compute all target tensors for efficient access (needed for class weights) self.targets = self._prepare_all_targets() print(f"Biomarkers configured: {self.biomarker_config.get_all_biomarker_names()}") print(f"Total output tensor size: {self.biomarker_config.total_output_size}") def _filter_age_records(self): """ Filter out records with AGE = "90+" for HIPAA compliance. Also ensures that remaining records have max age of 89. """ if 'AGE' not in self.df.columns: print("AGE column not found - skipping age filtering") return self.df original_count = len(self.df) # Filter out "90+" records age_90_plus_mask = self.df['AGE'] == '90+' age_90_plus_count = age_90_plus_mask.sum() if age_90_plus_count > 0: print(f"HIPAA Compliance: Filtering out {age_90_plus_count:,} records with AGE='90+'") self.df = self.df[~age_90_plus_mask].copy() # Convert remaining AGE values to numeric and verify max age is 89 numeric_age_mask = pd.to_numeric(self.df['AGE'], errors='coerce').notna() if not numeric_age_mask.all(): # Handle any non-numeric age values (shouldn't happen after filtering 90+) non_numeric_count = (~numeric_age_mask).sum() print(f"Found {non_numeric_count} non-numeric AGE values, filtering them out") self.df = self.df[numeric_age_mask].copy() # Convert to numeric and verify max age self.df['AGE'] = pd.to_numeric(self.df['AGE'], errors='coerce') if len(self.df) > 0: max_age = self.df['AGE'].max() min_age = self.df['AGE'].min() if max_age > 89: print(f"Warning: Maximum age is {max_age}, expected <= 89") else: print(f"Age range after filtering: {min_age:.0f} - {max_age:.0f} years") filtered_count = len(self.df) removed_count = original_count - filtered_count if removed_count > 0: print(f"Dataset filtering summary:") print(f" Original records: {original_count:,}") print(f" Removed records: {removed_count:,}") print(f" Remaining records: {filtered_count:,}") print(f" Removal rate: {removed_count/original_count*100:.1f}%") return self.df def __len__(self): """ Get length of dataset @return len : length of dataset """ return self.df.shape[0] def _prepare_all_targets(self): """Pre-compute all target tensors for the dataset""" import numpy as np targets = [] for idx in range(len(self.df)): data = self.df.iloc[idx] # Create tensor with the configured size t = torch.zeros(self.biomarker_config.total_output_size, dtype=torch.float32) # Process binary biomarkers for biomarker in self.biomarker_config.binary_biomarkers: if biomarker.name in data: layout = self.tensor_layout[biomarker.name] idx_start = layout.start_idx # Convert using configured classes or default Condition enum if biomarker.positive_class == "PRESENT" and biomarker.negative_class == "ABSENT": # Use default Condition converter t[idx_start] = Condition.convert(data[biomarker.name]) else: # Use custom class mapping if data[biomarker.name] == biomarker.positive_class: t[idx_start] = 1.0 elif data[biomarker.name] == biomarker.negative_class: t[idx_start] = 0.0 else: # Default to negative class for unknown values t[idx_start] = 0.0 # Process multiclass biomarkers for biomarker in self.biomarker_config.multiclass_biomarkers: if biomarker.name in data: layout = self.tensor_layout[biomarker.name] idx_start = layout.start_idx # Get class index and create one-hot encoding try: class_idx = biomarker.class_to_index(data[biomarker.name]) t[idx_start + class_idx] = 1.0 except ValueError: # Default to first class if unknown value print(f"Warning: Unknown value '{data[biomarker.name]}' for {biomarker.name}, using first class") t[idx_start] = 1.0 # Process continuous biomarkers for biomarker in self.biomarker_config.continuous_biomarkers: if biomarker.name in data: layout = self.tensor_layout[biomarker.name] idx_start = layout.start_idx # Normalize the continuous value raw_value = float(data[biomarker.name]) normalized_value = biomarker.normalize(raw_value) t[idx_start] = normalized_value targets.append(t.numpy()) return np.array(targets) def __getitem__(self, idx): """ Gets data at a certain index @param idx : idx of data desired @return xray : xray image at idx @return tensor : tensor of biomarker values at idx """ data = self.df.iloc[idx] # Get pre-computed targets t = torch.tensor(self.targets[idx], dtype=torch.float32) # Load and process image xray = Image.open(os.path.join(self.data_path, 'data', data['FILE'] + '.png')) xray = xray.resize((self.size, self.size), Image.LANCZOS) xray = xray.convert('L') if self.transforms: xray = self.transforms(xray) return xray, t def at(self,idx): """ Gets directory name for a certain index @param idx : idx of data directory desired @return name : name of study at idx """ return self.df.iloc[idx]['FILE'].split('.')[0] class PredictionDataset(Dataset): """Prediction-only dataset that loads input images without labels.""" def __init__(self, data_path, transforms=None, size=256): if not os.path.exists(data_path): raise IOError(f'Path given for PredictionDataset {data_path} does not exist...') self.data_path = data_path valid_exts = (".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff", ".webp") self.data = sorted( fname for fname in os.listdir(data_path) if fname.lower().endswith(valid_exts) ) self.size = size self.transforms = transforms def __len__(self): return len(self.data) def __getitem__(self, idx): fname = self.data[idx] xray = Image.open(os.path.join(self.data_path, fname)) xray = xray.resize((self.size, self.size), Image.LANCZOS) xray = xray.convert('L') if self.transforms: xray = self.transforms(xray) return xray def at(self, idx): return self.data[idx] if __name__ == "__main__": from torch.utils.data import DataLoader c = ClassifierDataset('data') print(len(c)) print(c[0][0].shape) print(c[0][1].shape) print(c[0][1]) print(c.at(2)) data = DataLoader(c, batch_size=4, shuffle=True) for s in data: print(s[0][0].shape, s[1][0], s[1][0].shape) print(s[0][1].shape, s[1][1], s[1][1].shape) print(s[0][2].shape, s[1][2], s[1][2].shape) print(s[0][3].shape, s[1][3], s[1][3].shape) break