Datasets:
File size: 9,529 Bytes
fe39cc9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 | 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
|