training and testing code for AbdCTBench

code/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 apyrros
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

code/config/__init__.py

@@ -0,0 +1 @@
+# Configuration module for multi-task comorbidity detection

code/config/biomarker_config.py

@@ -0,0 +1,413 @@
+"""
+Flexible Biomarker Configuration System
+Supports dynamic task configuration without hardcoded assumptions
+"""
+
+import yaml
+import json
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+
+
+@dataclass
+class BinaryBiomarker:
+    """Configuration for a binary classification task"""
+    name: str
+    description: str
+    positive_class: str
+    negative_class: str = "ABSENT"
+    class_weight: Optional[float] = None
+
+
+@dataclass  
+class MulticlassBiomarker:
+    """Configuration for a multiclass classification task"""
+    name: str
+    description: str
+    classes: List[str]
+    class_weights: Optional[Dict[str, float]] = None
+
+
+@dataclass
+class ContinuousBiomarker:
+    """Configuration for a regression task"""
+    name: str
+    description: str
+    min_value: float
+    max_value: float
+    normalization: str = "min_max"  # "min_max", "z_score", or "none"
+
+    def __post_init__(self):
+        """Validate continuous biomarker configuration."""
+        if self.max_value <= self.min_value:
+            raise ValueError(
+                f"Invalid range for {self.name}: max_value ({self.max_value}) "
+                f"must be greater than min_value ({self.min_value})"
+            )
+        if self.normalization not in {"min_max", "z_score", "none"}:
+            raise ValueError(
+                f"Unsupported normalization '{self.normalization}' for {self.name}. "
+                "Expected one of: min_max, z_score, none."
+            )
+    
+    def normalize(self, value: float) -> float:
+        """Normalize a continuous value based on the configured normalization method"""
+        if self.normalization == "min_max":
+            # Min-max normalization to [0, 1]
+            return (value - self.min_value) / (self.max_value - self.min_value)
+        elif self.normalization == "z_score":
+            # Z-score normalization (would need mean and std, using min_max for now)
+            return (value - self.min_value) / (self.max_value - self.min_value)
+        elif self.normalization == "none":
+            # No normalization
+            return value
+        else:
+            # Default to min_max
+            return (value - self.min_value) / (self.max_value - self.min_value)
+    
+    def denormalize(self, normalized_value: float) -> float:
+        """Denormalize a normalized value back to original scale"""
+        if self.normalization == "min_max":
+            # Reverse min-max normalization from [0, 1] to original range
+            return normalized_value * (self.max_value - self.min_value) + self.min_value
+        elif self.normalization == "z_score":
+            # Reverse z-score normalization (would need mean and std, using min_max for now)
+            return normalized_value * (self.max_value - self.min_value) + self.min_value
+        elif self.normalization == "none":
+            # No normalization
+            return normalized_value
+        else:
+            # Default to min_max
+            return normalized_value * (self.max_value - self.min_value) + self.min_value
+
+
+@dataclass
+class TensorLayout:
+    """Describes where each biomarker appears in the output tensor"""
+    biomarker_name: str
+    start_idx: int
+    end_idx: int
+    size: int
+    task_type: str  # "binary", "multiclass", "continuous"
+
+
+class FlexibleBiomarkerConfig:
+    """Flexible biomarker configuration that adapts to any task structure"""
+    
+    def __init__(self, config_path: Optional[str] = None):
+        self.experiment_name: str = ""
+        self.description: str = ""
+        self.binary_biomarkers: List[BinaryBiomarker] = []
+        self.multiclass_biomarkers: List[MulticlassBiomarker] = []
+        self.continuous_biomarkers: List[ContinuousBiomarker] = []
+        self.preprocessing: Dict[str, Any] = {}
+        self.training: Dict[str, Any] = {}
+        self.validation: Dict[str, Any] = {}
+        
+        if config_path:
+            self.load_from_file(config_path)
+    
+    def load_from_file(self, config_path: str):
+        """Load configuration from YAML or JSON file"""
+        if config_path.endswith('.yaml') or config_path.endswith('.yml'):
+            with open(config_path, 'r') as f:
+                config_data = yaml.safe_load(f)
+        elif config_path.endswith('.json'):
+            with open(config_path, 'r') as f:
+                config_data = json.load(f)
+        else:
+            raise ValueError(f"Unsupported config file format: {config_path}")
+        
+        self._parse_config(config_data)
+    
+    def _parse_config(self, config_data: Dict[str, Any]):
+        """Parse configuration data"""
+        self.experiment_name = config_data.get('experiment_name', '')
+        self.description = config_data.get('description', '')
+        
+        # Parse binary biomarkers
+        binary_data = config_data.get('binary_biomarkers', [])
+        self.binary_biomarkers = [
+            BinaryBiomarker(
+                name=b['name'],
+                description=b['description'],
+                positive_class=b['positive_class'],
+                negative_class=b.get('negative_class', 'ABSENT'),
+                class_weight=b.get('class_weight')
+            )
+            for b in binary_data
+        ]
+        
+        # Parse multiclass biomarkers
+        multiclass_data = config_data.get('multiclass_biomarkers', [])
+        self.multiclass_biomarkers = [
+            MulticlassBiomarker(
+                name=m['name'],
+                description=m['description'],
+                classes=m['classes'],
+                class_weights=m.get('class_weights')
+            )
+            for m in multiclass_data
+        ]
+        
+        # Parse continuous biomarkers
+        continuous_data = config_data.get('continuous_biomarkers', [])
+        self.continuous_biomarkers = [
+            ContinuousBiomarker(
+                name=c['name'],
+                description=c['description'],
+                min_value=c['min_value'],
+                max_value=c['max_value'],
+                normalization=c.get('normalization', 'min_max')
+            )
+            for c in continuous_data
+        ]
+        
+        # Parse other settings
+        self.preprocessing = config_data.get('preprocessing', {})
+        self.training = config_data.get('training', {})
+        self.validation = config_data.get('validation', {})
+    
+    @property
+    def num_binary_tasks(self) -> int:
+        """Number of binary classification tasks"""
+        return len(self.binary_biomarkers)
+    
+    @property
+    def num_multiclass_tasks(self) -> int:
+        """Number of multiclass classification tasks"""
+        return len(self.multiclass_biomarkers)
+    
+    @property
+    def num_continuous_tasks(self) -> int:
+        """Number of regression tasks"""
+        return len(self.continuous_biomarkers)
+    
+    @property
+    def total_multiclass_outputs(self) -> int:
+        """Total outputs needed for all multiclass tasks"""
+        return sum(len(m.classes) for m in self.multiclass_biomarkers)
+    
+    @property
+    def total_output_size(self) -> int:
+        """Total size of output tensor"""
+        return (self.num_binary_tasks + 
+                self.total_multiclass_outputs + 
+                self.num_continuous_tasks)
+    
+    def get_tensor_layout(self) -> Dict[str, TensorLayout]:
+        """Get the layout of biomarkers in the output tensor"""
+        layout = {}
+        current_idx = 0
+        
+        # Binary biomarkers (1 output each)
+        for biomarker in self.binary_biomarkers:
+            layout[biomarker.name] = TensorLayout(
+                biomarker_name=biomarker.name,
+                start_idx=current_idx,
+                end_idx=current_idx + 1,
+                size=1,
+                task_type="binary"
+            )
+            current_idx += 1
+        
+        # Multiclass biomarkers (n outputs each)
+        for biomarker in self.multiclass_biomarkers:
+            num_classes = len(biomarker.classes)
+            layout[biomarker.name] = TensorLayout(
+                biomarker_name=biomarker.name,
+                start_idx=current_idx,
+                end_idx=current_idx + num_classes,
+                size=num_classes,
+                task_type="multiclass"
+            )
+            current_idx += num_classes
+        
+        # Continuous biomarkers (1 output each)
+        for biomarker in self.continuous_biomarkers:
+            layout[biomarker.name] = TensorLayout(
+                biomarker_name=biomarker.name,
+                start_idx=current_idx,
+                end_idx=current_idx + 1,
+                size=1,
+                task_type="continuous"
+            )
+            current_idx += 1
+        
+        return layout
+    
+    def get_all_biomarker_names(self) -> List[str]:
+        """Get names of all biomarkers"""
+        names = []
+        names.extend([b.name for b in self.binary_biomarkers])
+        names.extend([m.name for m in self.multiclass_biomarkers])
+        names.extend([c.name for c in self.continuous_biomarkers])
+        return names
+    
+    def validate_dataset_compatibility(self, df: pd.DataFrame) -> Tuple[bool, List[str]]:
+        """Check if dataset has all required biomarker columns"""
+        required_columns = self.get_all_biomarker_names()
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        
+        is_compatible = len(missing_columns) == 0
+        return is_compatible, missing_columns
+    
+    def prepare_targets_tensor(self, df: pd.DataFrame, indices: Optional[List[int]] = None) -> np.ndarray:
+        """
+        Convert dataframe rows to target tensors for training
+        
+        Args:
+            df: DataFrame with biomarker columns
+            indices: Optional list of row indices to process (if None, process all)
+            
+        Returns:
+            numpy array of shape [num_samples, total_output_size]
+        """
+        if indices is None:
+            indices = list(range(len(df)))
+        
+        num_samples = len(indices)
+        targets = np.zeros((num_samples, self.total_output_size))
+        layout = self.get_tensor_layout()
+        
+        for i, row_idx in enumerate(indices):
+            row = df.iloc[row_idx]
+            
+            # Process binary biomarkers
+            for biomarker in self.binary_biomarkers:
+                tensor_info = layout[biomarker.name]
+                value = row[biomarker.name]
+                
+                # Convert to binary (1 if positive_class, 0 otherwise)
+                if pd.isna(value):
+                    binary_value = 0.0  # Default to negative class for missing values
+                elif str(value).upper() == biomarker.positive_class.upper():
+                    binary_value = 1.0
+                else:
+                    binary_value = 0.0
+                
+                targets[i, tensor_info.start_idx] = binary_value
+            
+            # Process multiclass biomarkers
+            for biomarker in self.multiclass_biomarkers:
+                tensor_info = layout[biomarker.name]
+                value = str(row[biomarker.name]).upper()
+                
+                # Create one-hot encoding
+                class_idx = -1
+                for j, class_name in enumerate(biomarker.classes):
+                    if value == class_name.upper():
+                        class_idx = j
+                        break
+                
+                if class_idx >= 0:
+                    targets[i, tensor_info.start_idx + class_idx] = 1.0
+                # If no match found, leave as zeros (unknown class)
+            
+            # Process continuous biomarkers
+            for biomarker in self.continuous_biomarkers:
+                tensor_info = layout[biomarker.name]
+                value = row[biomarker.name]
+                
+                if pd.isna(value):
+                    normalized_value = 0.0  # Default for missing values
+                else:
+                    normalized_value = biomarker.normalize(float(value))
+                    if biomarker.normalization in {"min_max", "z_score"}:
+                        # Keep normalized targets bounded for training stability.
+                        normalized_value = float(np.clip(normalized_value, 0.0, 1.0))
+                
+                targets[i, tensor_info.start_idx] = normalized_value
+        
+        return targets
+    
+    def denormalize_continuous_predictions(self, predictions: np.ndarray) -> Dict[str, np.ndarray]:
+        """Convert normalized continuous predictions back to original scale"""
+        layout = self.get_tensor_layout()
+        denormalized = {}
+        
+        for biomarker in self.continuous_biomarkers:
+            tensor_info = layout[biomarker.name]
+            normalized_preds = predictions[:, tensor_info.start_idx]
+
+            original_preds = np.array([biomarker.denormalize(v) for v in normalized_preds], dtype=np.float32)
+            denormalized[biomarker.name] = original_preds
+        
+        return denormalized
+    
+    def save_to_file(self, file_path: str):
+        """Save configuration to file"""
+        config_data = {
+            'experiment_name': self.experiment_name,
+            'description': self.description,
+            'binary_biomarkers': [
+                {
+                    'name': b.name,
+                    'description': b.description,
+                    'positive_class': b.positive_class,
+                    'negative_class': b.negative_class
+                }
+                for b in self.binary_biomarkers
+            ],
+            'multiclass_biomarkers': [
+                {
+                    'name': m.name,
+                    'description': m.description,
+                    'classes': m.classes
+                }
+                for m in self.multiclass_biomarkers
+            ],
+            'continuous_biomarkers': [
+                {
+                    'name': c.name,
+                    'description': c.description,
+                    'min_value': c.min_value,
+                    'max_value': c.max_value,
+                    'normalization': c.normalization
+                }
+                for c in self.continuous_biomarkers
+            ],
+            'preprocessing': self.preprocessing,
+            'training': self.training,
+            'validation': self.validation
+        }
+        
+        if file_path.endswith('.yaml') or file_path.endswith('.yml'):
+            with open(file_path, 'w') as f:
+                yaml.safe_dump(config_data, f, default_flow_style=False, sort_keys=False, indent=2)
+        elif file_path.endswith('.json'):
+            with open(file_path, 'w') as f:
+                json.dump(config_data, f, indent=2)
+        else:
+            raise ValueError(f"Unsupported file format: {file_path}")
+    
+    def print_summary(self):
+        """Print a summary of the configuration"""
+        print(f"Experiment: {self.experiment_name}")
+        print(f"Description: {self.description}")
+        print(f"\nTask Configuration:")
+        print(f"  Binary tasks: {self.num_binary_tasks}")
+        print(f"  Multiclass tasks: {self.num_multiclass_tasks}")
+        print(f"  Continuous tasks: {self.num_continuous_tasks}")
+        print(f"  Total output size: {self.total_output_size}")
+        
+        print(f"\nBinary Biomarkers:")
+        for b in self.binary_biomarkers:
+            print(f"  - {b.name}: {b.description}")
+        
+        if self.multiclass_biomarkers:
+            print(f"\nMulticlass Biomarkers:")
+            for m in self.multiclass_biomarkers:
+                print(f"  - {m.name}: {m.description} ({len(m.classes)} classes)")
+        
+        print(f"\nContinuous Biomarkers:")
+        for c in self.continuous_biomarkers:
+            print(f"  - {c.name}: {c.description} (range: {c.min_value}-{c.max_value})")
+        
+        print(f"\nTensor Layout:")
+        layout = self.get_tensor_layout()
+        for name, info in layout.items():
+            print(f"  {name}: indices {info.start_idx}-{info.end_idx-1} (size: {info.size}, type: {info.task_type})")
+

code/config/biomarker_config_multitask_example.json

@@ -0,0 +1,62 @@
+{
+  "experiment_name": "comorbidities_detection_multitask",
+  "description": "Multi-task prediction of comorbidities and demographics from AbdCTBench",
+
+  "binary_biomarkers": [
+    {"name": "MORTALITY",   "description": "Death in the followup period", "positive_class": "PRESENT"},
+    {"name": "HCC12",       "description": "HCC code 12 — Breast, Prostate, and other cancers", "positive_class": "PRESENT"},
+    {"name": "HCC18",       "description": "HCC code 18 — Diabetes with Chronic Complications", "positive_class": "PRESENT"},
+    {"name": "HCC96",       "description": "HCC code 96 — Cardiac arrhythmias", "positive_class": "PRESENT"},
+    {"name": "HCC108",      "description": "HCC code 108 — Vascular disease", "positive_class": "PRESENT"},
+    {"name": "HCC111",      "description": "HCC code 111 — Chronic obstructive pulmonary disease", "positive_class": "PRESENT"},
+    {"name": "T2D",         "description": "Type 2 Diabetes", "positive_class": "PRESENT"},
+    {"name": "MI",          "description": "Myocardial Infarction", "positive_class": "PRESENT"},
+    {"name": "CALCIUMSCORING_ABDOMINALAGATSTON_BINARY", "description": "High abdominal aortic calcium score (Agatston > 1000)", "positive_class": "PRESENT"}
+  ],
+
+  "multiclass_biomarkers": [],
+
+  "continuous_biomarkers": [
+    {
+      "name": "AGE",
+      "description": "Patient age in years (min-max normalized to [0, 1] during training)",
+      "min_value": 18,
+      "max_value": 89,
+      "normalization": "min_max"
+    }
+  ],
+
+  "preprocessing": {
+    "image_size": 256,
+    "normalize_images": true,
+    "convert_to_rgb": true
+  },
+
+  "training": {
+    "class_weighting": true,
+    "balanced_sampling": true
+  },
+
+  "validation": {
+    "threshold_optimization": true,
+    "optimization_metric": "f1_score",
+    "per_biomarker_thresholds": true,
+    "threshold_search_range": [0.1, 0.9],
+    "threshold_search_steps": 9,
+    "fallback_threshold": 0.5,
+    "metrics": [
+      "auroc",
+      "accuracy",
+      "sensitivity",
+      "specificity",
+      "f1_score",
+      "precision",
+      "recall"
+    ],
+    "regression_metrics": [
+      "mse",
+      "mae",
+      "r2_score"
+    ]
+  }
+}

code/config/biomarker_config_multitask_example.yaml

@@ -0,0 +1,103 @@
+# Multi-Task Biomarker Configuration — Published Experiments
+#
+# Pass this file to --biomarker_config in train.py or test.py.
+#
+# For a minimal single-task example with detailed field descriptions,
+# see biomarker_config_single_task_example.yaml.
+
+experiment_name: "comorbidities_detection_multitask"
+description: "Multi-task prediction of comorbidities and demographics from AbdCTBench"
+
+# -------------------------------------------------------------------------
+# Binary classification tasks (9 targets)
+# -------------------------------------------------------------------------
+binary_biomarkers:
+  - name: "MORTALITY"
+    description: "Death in the followup period"
+    positive_class: "PRESENT"
+
+  - name: "HCC12"
+    description: "HCC code 12 — Breast, Prostate, and other cancers"
+    positive_class: "PRESENT"
+
+  - name: "HCC18"
+    description: "HCC code 18 — Diabetes with Chronic Complications"
+    positive_class: "PRESENT"
+
+  - name: "HCC96"
+    description: "HCC code 96 — Cardiac arrhythmias"
+    positive_class: "PRESENT"
+
+  - name: "HCC108"
+    description: "HCC code 108 — Vascular disease"
+    positive_class: "PRESENT"
+
+  - name: "HCC111"
+    description: "HCC code 111 — Chronic obstructive pulmonary disease"
+    positive_class: "PRESENT"
+
+  - name: "T2D"
+    description: "Type 2 Diabetes"
+    positive_class: "PRESENT"
+
+  - name: "MI"
+    description: "Myocardial Infarction"
+    positive_class: "PRESENT"
+
+  - name: "CALCIUMSCORING_ABDOMINALAGATSTON_BINARY"
+    description: "High abdominal aortic calcium score (Agatston > 1000)"
+    positive_class: "PRESENT"
+
+# -------------------------------------------------------------------------
+# Multiclass classification tasks
+# -------------------------------------------------------------------------
+multiclass_biomarkers: []
+
+# -------------------------------------------------------------------------
+# Continuous regression tasks (1 target)
+# -------------------------------------------------------------------------
+continuous_biomarkers:
+  - name: "AGE"
+    description: "Patient age in years (min-max normalized to [0, 1] during training)"
+    min_value: 18
+    max_value: 89
+    normalization: "min_max"
+
+# -------------------------------------------------------------------------
+# Preprocessing settings
+# -------------------------------------------------------------------------
+preprocessing:
+  image_size: 256
+  normalize_images: true
+  convert_to_rgb: true
+
+# -------------------------------------------------------------------------
+# Training settings
+# -------------------------------------------------------------------------
+training:
+  class_weighting: true
+  balanced_sampling: true
+
+# -------------------------------------------------------------------------
+# Validation / threshold settings
+# -------------------------------------------------------------------------
+validation:
+  threshold_optimization: true
+  optimization_metric: "f1_score"
+  per_biomarker_thresholds: true
+  threshold_search_range: [0.1, 0.9]
+  threshold_search_steps: 9
+  fallback_threshold: 0.5
+
+  metrics:
+    - "auroc"
+    - "accuracy"
+    - "sensitivity"
+    - "specificity"
+    - "f1_score"
+    - "precision"
+    - "recall"
+  regression_metrics:
+    - "mse"
+    - "mae"
+    - "r2_score"

code/config/biomarker_config_single_task_example.json

@@ -0,0 +1,51 @@
+{
+  "experiment_name": "mortality_single_task",
+  "description": "Single-task prediction of Mortality in AbdCTBench",
+
+  "binary_biomarkers": [
+    {
+      "name": "MORTALITY",
+      "description": "Death status",
+      "positive_class": "PRESENT",
+      "negative_class": "ABSENT"
+    }
+  ],
+
+  "multiclass_biomarkers": [],
+
+  "continuous_biomarkers": [],
+
+  "preprocessing": {
+    "image_size": 256,
+    "normalize_images": true,
+    "convert_to_rgb": true
+  },
+
+  "training": {
+    "class_weighting": true,
+    "balanced_sampling": true
+  },
+
+  "validation": {
+    "threshold_optimization": true,
+    "optimization_metric": "f1_score",
+    "per_biomarker_thresholds": true,
+    "threshold_search_range": [0.1, 0.9],
+    "threshold_search_steps": 9,
+    "fallback_threshold": 0.5,
+    "metrics": [
+      "auroc",
+      "accuracy",
+      "sensitivity",
+      "specificity",
+      "f1_score",
+      "precision",
+      "recall"
+    ],
+    "regression_metrics": [
+      "mse",
+      "mae",
+      "r2_score"
+    ]
+  }
+}

code/config/biomarker_config_single_task_example.yaml

@@ -0,0 +1,95 @@
+# Single-Task Biomarker Configuration Example
+#
+# This file shows how to configure training for a single prediction target.
+# Pass this file to --biomarker_config in train.py or test.py.
+#
+# To define your own config, copy this file, edit the biomarker entries,
+# and point --biomarker_config at your new file.
+#
+# For the full multi-task configuration used in the published experiments,
+# see biomarker_config_multitask_example.yaml.
+
+experiment_name: "mortality_single_task"
+description: "Single-task prediction of Mortality in AbdCTBench"
+
+# -------------------------------------------------------------------------
+# Binary classification tasks  (output: sigmoid probability, label: 0 or 1)
+# -------------------------------------------------------------------------
+# Each entry requires:
+#   name          - column name in train.csv / val.csv / test.csv
+#   description   - human-readable label (informational only)
+#   positive_class - the CSV value that maps to label=1
+#   negative_class - the CSV value that maps to label=0  (default: "ABSENT")
+#
+# Available binary targets in AbdCTBench:
+#   MORTALITY, HCC12, HCC18, HCC96, HCC108,
+#   CALCIUMSCORING_ABDOMINALAGATSTON_BINARY
+binary_biomarkers:
+  - name: "MORTALITY"
+    description: "Death status"
+    positive_class: "PRESENT"
+    negative_class: "ABSENT"
+
+# -------------------------------------------------------------------------
+# Multiclass classification tasks  (output: softmax probabilities)
+# -------------------------------------------------------------------------
+# Each entry requires:
+#   name    - column name in the CSV
+#   classes - ordered list of class labels (determines one-hot encoding order)
+#
+# Leave empty if not needed.
+multiclass_biomarkers: []
+
+# -------------------------------------------------------------------------
+# Continuous regression tasks  (output: raw continuous value)
+# -------------------------------------------------------------------------
+# Each entry requires:
+#   name          - column name in the CSV
+#   min_value     - minimum expected value (used for min-max normalization)
+#   max_value     - maximum expected value
+#   normalization - normalization method; currently only "min_max" is supported
+#
+# The model predicts a normalized value in [0, 1]; metrics are reported on
+# the denormalized scale.
+#
+# Leave empty if not needed.
+continuous_biomarkers: []
+
+# -------------------------------------------------------------------------
+# Preprocessing settings
+# -------------------------------------------------------------------------
+preprocessing:
+  image_size: 256        # images are resized to this square size
+  normalize_images: true
+  convert_to_rgb: true   # grayscale CT slices are replicated to 3 channels
+
+# -------------------------------------------------------------------------
+# Training settings
+# -------------------------------------------------------------------------
+training:
+  class_weighting: true    # use inverse-frequency weighting for binary tasks
+  balanced_sampling: true  # balanced batch sampling
+
+# -------------------------------------------------------------------------
+# Validation / threshold settings
+# -------------------------------------------------------------------------
+validation:
+  threshold_optimization: true
+  optimization_metric: "f1_score"   # metric used to pick the best decision threshold
+  per_biomarker_thresholds: true    # optimize a separate threshold per biomarker
+  threshold_search_range: [0.1, 0.9]
+  threshold_search_steps: 9         # evaluates thresholds 0.1, 0.2, ..., 0.9
+  fallback_threshold: 0.5
+
+  metrics:
+    - "auroc"
+    - "accuracy"
+    - "sensitivity"
+    - "specificity"
+    - "f1_score"
+    - "precision"
+    - "recall"
+  regression_metrics:
+    - "mse"
+    - "mae"
+    - "r2_score"

code/config/experiment_config.py

@@ -0,0 +1,240 @@
+"""
+Experiment Configuration System
+Handles experiment parameters for training and evaluation
+"""
+
+import ast
+from dataclasses import dataclass
+from typing import List, Dict, Any
+import os
+
+
+# Per-model defaults for pretrained_weights and single_target_strategy.
+# These are sourced from the experimentation plan used in the published results.
+# Users can override both via --pretrained_weights and --single_target_strategy CLI flags.
+MODEL_DEFAULTS: Dict[str, Dict[str, str]] = {
+    "ResNet-18":   {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
+    "ResNet-34":   {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
+    "DenseNet-121":{"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
+    "EfficientNet-B0": {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"},
+    "ViT-Small (DINOv2)": {"pretrained_weights": "DINOv2 (self-supervised)",  "single_target_strategy": "CLS token classification"},
+    "Swin Transformer-Base": {"pretrained_weights": "ImageNet-22K", "single_target_strategy": "CLS token classification"},
+    "ResNet-50 (RadImageNet)": {"pretrained_weights": "RadImageNet", "single_target_strategy": "Direct classification head"},
+}
+
+DEFAULT_AUGMENTATION_PARAMS: Dict[str, Any] = {
+    "rotation": 15,
+    "horizontal_flip": True,
+    "random_crop": True,
+    "color_jitter": True,
+    "brightness": 0.2,
+    "contrast": 0.2,
+    "imagenet_norm": True,
+}
+
+DEFAULT_AUGMENTATIONS = DEFAULT_AUGMENTATION_PARAMS.copy()
+
+
+def get_model_defaults(model_name: str) -> Dict[str, str]:
+    """
+    Return the default pretrained_weights and single_target_strategy for a given model.
+    Falls back to ImageNet weights and Direct classification head for unknown models.
+    """
+    return MODEL_DEFAULTS.get(
+        model_name,
+        {"pretrained_weights": "ImageNet", "single_target_strategy": "Direct classification head"}
+    )
+
+
+@dataclass
+class ExperimentConfig:
+    """Configuration for a single experiment"""
+
+    # Model configuration
+    model: str
+    loss_function: str
+    must_include: bool
+    learning_rate: List[float]
+    batch_size: int
+    weight_decay: float
+    optimizer: str
+    scheduler: str
+
+    # Training configuration
+    image_augmentations: Dict[str, Any]
+    dropout: float
+    loss_specific_params: str
+    multi_target_strategy: str
+    single_target_strategy: str
+    pretrained_weights: str
+    fine_tuning_strategy: str
+
+    # System configuration
+    expected_gpu_memory: str
+    architectural_family: str
+    class_weighting: str
+    sampling_strategy: str
+    threshold_selection: str
+
+    # Additional configuration
+    experiment_name: str = ""
+    output_dir: str = ""
+
+    # GradNorm configuration
+    use_gradnorm: bool = False
+    gradnorm_alpha: float = 0.16
+    gradnorm_update_freq: int = 10
+
+    def __post_init__(self):
+        """Process configuration after initialization"""
+        if isinstance(self.learning_rate, str):
+            try:
+                self.learning_rate = ast.literal_eval(self.learning_rate)
+            except (ValueError, SyntaxError):
+                try:
+                    self.learning_rate = [float(self.learning_rate)]
+                except ValueError:
+                    self.learning_rate = [1e-4]
+
+        if not isinstance(self.learning_rate, list):
+            self.learning_rate = [self.learning_rate]
+
+        self.image_augmentations = normalize_augmentation_params(self.image_augmentations)
+
+        if not self.experiment_name:
+            self.experiment_name = self._generate_experiment_name()
+
+    def _generate_experiment_name(self) -> str:
+        """Generate a unique experiment name based on configuration"""
+        import datetime
+
+        model_clean = self.model.replace('/', '_').replace(' ', '_').replace('(', '').replace(')', '')
+        lr_str = f"lr{self.learning_rate[0]:.0e}" if len(self.learning_rate) == 1 else "lr_sweep"
+        batch_str = f"bs{self.batch_size}"
+
+        ft_suffix = ""
+        if "frozen" in self.fine_tuning_strategy.lower() or "probe" in self.fine_tuning_strategy.lower():
+            ft_suffix = "_frozen"
+        elif "partial" in self.fine_tuning_strategy.lower():
+            ft_suffix = "_partial"
+
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        return f"{model_clean}_{lr_str}_{batch_str}{ft_suffix}_{timestamp}"
+
+    def get_output_directory(self, base_dir: str) -> str:
+        """Get the output directory for this experiment"""
+        if self.output_dir:
+            return self.output_dir
+        return os.path.join(base_dir, self.experiment_name)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert configuration to dictionary"""
+        learning_rate_value = self.learning_rate[0] if len(self.learning_rate) == 1 else self.learning_rate
+
+        return {
+            'model': self.model,
+            'loss_function': self.loss_function,
+            'must_include': self.must_include,
+            'learning_rate': learning_rate_value,
+            'batch_size': self.batch_size,
+            'weight_decay': self.weight_decay,
+            'optimizer': self.optimizer,
+            'scheduler': self.scheduler,
+            'image_augmentations': self.image_augmentations,
+            'dropout': self.dropout,
+            'loss_specific_params': self.loss_specific_params,
+            'multi_target_strategy': self.multi_target_strategy,
+            'single_target_strategy': self.single_target_strategy,
+            'pretrained_weights': self.pretrained_weights,
+            'fine_tuning_strategy': self.fine_tuning_strategy,
+            'expected_gpu_memory': self.expected_gpu_memory,
+            'architectural_family': self.architectural_family,
+            'class_weighting': self.class_weighting,
+            'sampling_strategy': self.sampling_strategy,
+            'threshold_selection': self.threshold_selection,
+            'experiment_name': self.experiment_name,
+        }
+
+
+def normalize_augmentation_params(aug_input: Any) -> Dict[str, Any]:
+    """Normalize augmentation params into a validated parameter dictionary."""
+    aug_params = DEFAULT_AUGMENTATION_PARAMS.copy()
+
+    if aug_input is None:
+        return aug_params
+
+    if isinstance(aug_input, str):
+        try:
+            parsed = ast.literal_eval(aug_input)
+        except (ValueError, SyntaxError) as exc:
+            raise ValueError(
+                "image_augmentations must be a dict (or a dict-like string), "
+                "not a free-form text description."
+            ) from exc
+        aug_input = parsed
+
+    if not isinstance(aug_input, dict):
+        raise ValueError("image_augmentations must be a dictionary of augmentation params.")
+
+    aug_params.update(aug_input)
+
+    # Enforce expected types
+    aug_params["rotation"] = int(aug_params["rotation"])
+    aug_params["horizontal_flip"] = bool(aug_params["horizontal_flip"])
+    aug_params["random_crop"] = bool(aug_params["random_crop"])
+    aug_params["color_jitter"] = bool(aug_params["color_jitter"])
+    aug_params["brightness"] = float(aug_params["brightness"])
+    aug_params["contrast"] = float(aug_params["contrast"])
+    aug_params["imagenet_norm"] = bool(aug_params["imagenet_norm"])
+
+    return aug_params
+
+
+def parse_augmentation_string(aug_input: Any) -> Dict[str, Any]:
+    """Backward-compatible alias for older imports/call sites."""
+    return normalize_augmentation_params(aug_input)
+
+
+def create_optimizer(model_parameters, config: 'ExperimentConfig'):
+    """Create optimizer based on configuration"""
+    import torch.optim as optim
+
+    if config.optimizer == 'AdamW':
+        return optim.AdamW(
+            model_parameters,
+            lr=config.learning_rate[0],
+            weight_decay=config.weight_decay
+        )
+    elif config.optimizer == 'Adam':
+        return optim.Adam(
+            model_parameters,
+            lr=config.learning_rate[0],
+            weight_decay=config.weight_decay
+        )
+    elif config.optimizer == 'SGD':
+        return optim.SGD(
+            model_parameters,
+            lr=config.learning_rate[0],
+            weight_decay=config.weight_decay,
+            momentum=0.9
+        )
+    else:
+        raise ValueError(f"Unsupported optimizer: {config.optimizer}")
+
+
+def create_scheduler(optimizer, config: 'ExperimentConfig', total_epochs: int):
+    """Create learning rate scheduler based on configuration"""
+    import torch.optim.lr_scheduler as lr_scheduler
+
+    if config.scheduler == 'CosineAnnealing':
+        return lr_scheduler.CosineAnnealingLR(optimizer, T_max=total_epochs)
+    elif config.scheduler == 'CosineAnnealingWarmRestarts':
+        return lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2)
+    elif config.scheduler == 'ReduceLROnPlateau':
+        return lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', patience=10, factor=0.5)
+    elif config.scheduler == 'StepLR':
+        return lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)
+    elif config.scheduler == 'ExponentialLR':
+        return lr_scheduler.ExponentialLR(optimizer, gamma=0.95)
+    else:
+        raise ValueError(f"Unsupported scheduler: {config.scheduler}")

code/dataset.py

@@ -0,0 +1,239 @@
+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

code/model/flexible_multitask_head.py

@@ -0,0 +1,686 @@
+"""
+Flexible Multi-Task Head and Loss Function
+Adapts to any biomarker configuration without hardcoded assumptions
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from typing import Dict, List, Tuple, Any, Union, Optional
+import logging
+from config.biomarker_config import FlexibleBiomarkerConfig, TensorLayout
+from .single_target_strategies import (
+    SingleTargetStrategy, 
+    create_feature_extractor,
+    get_strategy_from_name
+)
+
+logger = logging.getLogger(__name__)
+
+
+class FlexibleMultiTaskHead(nn.Module):
+    """Flexible multi-task head that adapts to biomarker configuration"""
+    
+    def __init__(
+        self,
+        input_dim: int,
+        biomarker_config: FlexibleBiomarkerConfig,
+        dropout: float = 0.1,
+        single_target_strategy: Optional[Union[str, SingleTargetStrategy]] = None,
+        target_feature_dim: Optional[int] = None
+    ):
+        super().__init__()
+        
+        self.biomarker_config = biomarker_config
+        self.tensor_layout = biomarker_config.get_tensor_layout()
+        
+        # Handle single-target strategy
+        self.single_target_strategy = None
+        self.feature_extractor = None
+        self.target_feature_dim = target_feature_dim
+
+        if single_target_strategy is not None:
+            if isinstance(single_target_strategy, str):
+                self.single_target_strategy = get_strategy_from_name(single_target_strategy)
+            else:
+                self.single_target_strategy = single_target_strategy
+
+            # Create appropriate feature extractor with target feature dimension
+            feature_dim = target_feature_dim if target_feature_dim is not None else input_dim
+            self.feature_extractor = create_feature_extractor(
+                self.single_target_strategy,
+                input_dim,
+                feature_dim=feature_dim,
+                dropout=dropout
+            )
+
+            # Use feature extractor output dimension
+            processed_input_dim = self.feature_extractor.output_dim
+        else:
+            # Default behavior - use original input dimension
+            processed_input_dim = input_dim
+        
+        # Shared feature processing (only if no single-target strategy is used)
+        if self.single_target_strategy is None:
+            # Use target_feature_dim if provided, otherwise use 512 as default
+            output_dim = target_feature_dim if target_feature_dim is not None else 512
+            self.shared_layers = nn.Sequential(
+                nn.Linear(input_dim, output_dim),
+                nn.ReLU(inplace=True),
+                nn.Dropout(dropout),
+                nn.BatchNorm1d(output_dim)
+            )
+            processed_input_dim = output_dim
+        else:
+            # Skip shared layers when using single-target strategy
+            self.shared_layers = nn.Identity()
+            processed_input_dim = self.feature_extractor.output_dim
+        
+        # Task-specific heads
+        self.task_heads = nn.ModuleDict()
+        
+        # Binary classification heads (one per biomarker)
+        for biomarker in biomarker_config.binary_biomarkers:
+            self.task_heads[f"binary_{biomarker.name}"] = nn.Linear(processed_input_dim, 1)
+        
+        # Multiclass classification heads
+        for biomarker in biomarker_config.multiclass_biomarkers:
+            num_classes = len(biomarker.classes)
+            self.task_heads[f"multiclass_{biomarker.name}"] = nn.Linear(processed_input_dim, num_classes)
+        
+        # Regression heads (one per biomarker)
+        for biomarker in biomarker_config.continuous_biomarkers:
+            self.task_heads[f"continuous_{biomarker.name}"] = nn.Linear(processed_input_dim, 1)
+    
+    def forward(self, x):
+        """
+        Forward pass
+        
+        Args:
+            x: Input features [batch_size, input_dim] or [batch_size, C, H, W] for spatial features
+            
+        Returns:
+            Concatenated outputs [batch_size, total_output_size]
+        """
+        # Apply single-target strategy feature extraction if specified
+        if self.single_target_strategy is not None and self.feature_extractor is not None:
+            shared_features = self.feature_extractor(x)
+        else:
+            shared_features = self.shared_layers(x)
+        
+        outputs = []
+        
+        # Binary outputs
+        for biomarker in self.biomarker_config.binary_biomarkers:
+            head_name = f"binary_{biomarker.name}"
+            binary_out = self.task_heads[head_name](shared_features)  # [B, 1]
+            outputs.append(binary_out)
+        
+        # Multiclass outputs
+        for biomarker in self.biomarker_config.multiclass_biomarkers:
+            head_name = f"multiclass_{biomarker.name}"
+            multiclass_out = self.task_heads[head_name](shared_features)  # [B, num_classes]
+            outputs.append(multiclass_out)
+        
+        # Regression outputs
+        for biomarker in self.biomarker_config.continuous_biomarkers:
+            head_name = f"continuous_{biomarker.name}"
+            regression_out = self.task_heads[head_name](shared_features)  # [B, 1]
+            outputs.append(regression_out)
+        
+        # Concatenate all outputs
+        return torch.cat(outputs, dim=1)
+
+
+class LinearProbeMultiTaskHead(nn.Module):
+    """
+    True linear probe head - direct mapping from backbone features to task outputs
+    No shared layers, minimal parameters, maximum interpretability
+    """
+    
+    def __init__(
+        self,
+        input_dim: int,
+        biomarker_config: FlexibleBiomarkerConfig,
+        dropout: float = 0.0,
+        single_target_strategy: Optional[Union[str, SingleTargetStrategy]] = None,
+        target_feature_dim: Optional[int] = None
+    ):
+        super().__init__()
+        
+        self.biomarker_config = biomarker_config
+        self.tensor_layout = biomarker_config.get_tensor_layout()
+        
+        # Handle single-target strategy
+        self.single_target_strategy = None
+        self.feature_extractor = None
+        self.target_feature_dim = target_feature_dim
+
+        if single_target_strategy is not None:
+            if isinstance(single_target_strategy, str):
+                self.single_target_strategy = get_strategy_from_name(single_target_strategy)
+            else:
+                self.single_target_strategy = single_target_strategy
+
+            # Create appropriate feature extractor with target feature dimension
+            feature_dim = target_feature_dim if target_feature_dim is not None else input_dim
+            self.feature_extractor = create_feature_extractor(
+                self.single_target_strategy,
+                input_dim,
+                feature_dim=feature_dim,
+                dropout=0.0  # No dropout for linear probe
+            )
+
+            # Use feature extractor output dimension
+            processed_input_dim = self.feature_extractor.output_dim
+        else:
+            # Default behavior - use original input dimension
+            processed_input_dim = input_dim
+        
+        # Optional minimal dropout (usually 0.0 for true linear probe)
+        self.dropout = nn.Dropout(dropout) if dropout > 0 else nn.Identity()
+        
+        # Direct task-specific linear layers (no shared processing)
+        self.task_heads = nn.ModuleDict()
+        
+        # Binary classification heads - direct from backbone
+        for biomarker in biomarker_config.binary_biomarkers:
+            self.task_heads[f"binary_{biomarker.name}"] = nn.Linear(processed_input_dim, 1)
+        
+        # Multiclass classification heads - direct from backbone  
+        for biomarker in biomarker_config.multiclass_biomarkers:
+            num_classes = len(biomarker.classes)
+            self.task_heads[f"multiclass_{biomarker.name}"] = nn.Linear(processed_input_dim, num_classes)
+        
+        # Regression heads - direct from backbone
+        for biomarker in biomarker_config.continuous_biomarkers:
+            self.task_heads[f"continuous_{biomarker.name}"] = nn.Linear(processed_input_dim, 1)
+        
+        # Initialize weights for better convergence
+        self._initialize_weights()
+    
+    def _initialize_weights(self):
+        """Initialize linear layer weights for stable training"""
+        for name, module in self.task_heads.items():
+            if isinstance(module, nn.Linear):
+                # Xavier/Glorot initialization for linear layers
+                nn.init.xavier_uniform_(module.weight)
+                nn.init.zeros_(module.bias)
+    
+    def forward(self, x):
+        """
+        Direct forward pass - no shared processing
+        
+        Args:
+            x: Backbone features [batch_size, input_dim] or [batch_size, C, H, W] for spatial features
+            
+        Returns:
+            Concatenated outputs [batch_size, total_output_size]
+        """
+        # Apply single-target strategy feature extraction if specified
+        if self.single_target_strategy is not None and self.feature_extractor is not None:
+            features = self.feature_extractor(x)
+        else:
+            # Optional dropout on backbone features (usually disabled)
+            features = self.dropout(x)  # [batch_size, input_dim]
+        
+        outputs = []
+        
+        # Binary outputs - direct linear transformation
+        for biomarker in self.biomarker_config.binary_biomarkers:
+            head_name = f"binary_{biomarker.name}"
+            binary_out = self.task_heads[head_name](features)  # [B, 1]
+            outputs.append(binary_out)
+        
+        # Multiclass outputs - direct linear transformation
+        for biomarker in self.biomarker_config.multiclass_biomarkers:
+            head_name = f"multiclass_{biomarker.name}"
+            multiclass_out = self.task_heads[head_name](features)  # [B, num_classes]
+            outputs.append(multiclass_out)
+        
+        # Regression outputs - direct linear transformation
+        for biomarker in self.biomarker_config.continuous_biomarkers:
+            head_name = f"continuous_{biomarker.name}"
+            regression_out = self.task_heads[head_name](features)  # [B, 1]
+            outputs.append(regression_out)
+        
+        # Concatenate all outputs
+        return torch.cat(outputs, dim=1)  # [batch_size, total_output_size]
+
+
+class FlexibleMultiTaskLoss(nn.Module):
+    """Flexible multi-task loss function that adapts to biomarker configuration"""
+    
+    def __init__(self, biomarker_config: FlexibleBiomarkerConfig, class_weights: Dict[str, float] = None):
+        super().__init__()
+        
+        self.biomarker_config = biomarker_config
+        self.tensor_layout = biomarker_config.get_tensor_layout()
+        self.class_weights = class_weights or {}
+        
+        # Create weighted BCE losses for binary tasks
+        self.binary_losses = nn.ModuleDict()
+        for biomarker in biomarker_config.binary_biomarkers:
+            weight = self.class_weights.get(biomarker.name, 1.0)
+            if weight != 1.0:
+                pos_weight = torch.tensor([weight], dtype=torch.float32)
+                self.binary_losses[biomarker.name] = nn.BCEWithLogitsLoss(pos_weight=pos_weight)
+            else:
+                self.binary_losses[biomarker.name] = nn.BCEWithLogitsLoss()
+        
+        # Cross-entropy losses for multiclass tasks
+        self.multiclass_losses = nn.ModuleDict()
+        for biomarker in biomarker_config.multiclass_biomarkers:
+            self.multiclass_losses[biomarker.name] = nn.CrossEntropyLoss()
+        
+        # MSE losses for regression tasks
+        self.regression_losses = nn.ModuleDict()
+        for biomarker in biomarker_config.continuous_biomarkers:
+            self.regression_losses[biomarker.name] = nn.MSELoss()
+    
+    def forward(self, predictions: torch.Tensor, targets: torch.Tensor) -> Tuple[torch.Tensor, Dict[str, float]]:
+        """
+        Calculate multi-task loss
+        
+        Args:
+            predictions: [batch_size, total_output_size]
+            targets: [batch_size, total_output_size]
+            
+        Returns:
+            total_loss: Combined loss
+            loss_dict: Dictionary with individual loss components
+        """
+        device = predictions.device
+        
+        # Move pos_weight tensors to correct device
+        for biomarker_name, loss_fn in self.binary_losses.items():
+            if hasattr(loss_fn, 'pos_weight') and loss_fn.pos_weight is not None:
+                loss_fn.pos_weight = loss_fn.pos_weight.to(device)
+        
+        total_loss = 0.0
+        loss_components = {}
+        
+        # Binary classification losses
+        binary_losses = []
+        for biomarker in self.biomarker_config.binary_biomarkers:
+            layout = self.tensor_layout[biomarker.name]
+            
+            pred_slice = predictions[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            target_slice = targets[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            
+            loss_fn = self.binary_losses[biomarker.name]
+            binary_loss = loss_fn(pred_slice, target_slice)
+            binary_losses.append(binary_loss)
+            
+            loss_components[f'binary_{biomarker.name}'] = binary_loss.item()
+        
+        if binary_losses:
+            avg_binary_loss = torch.mean(torch.stack(binary_losses))
+            total_loss += avg_binary_loss
+            loss_components['avg_binary_loss'] = avg_binary_loss.item()
+        
+        # Multiclass classification losses
+        multiclass_losses = []
+        for biomarker in self.biomarker_config.multiclass_biomarkers:
+            layout = self.tensor_layout[biomarker.name]
+            
+            pred_slice = predictions[:, layout.start_idx:layout.end_idx]  # [B, num_classes]
+            target_slice = targets[:, layout.start_idx:layout.end_idx]  # [B, num_classes]
+            
+            # Convert one-hot targets to class indices
+            target_indices = torch.argmax(target_slice, dim=1)  # [B]
+            
+            loss_fn = self.multiclass_losses[biomarker.name]
+            multiclass_loss = loss_fn(pred_slice, target_indices)
+            multiclass_losses.append(multiclass_loss)
+            
+            loss_components[f'multiclass_{biomarker.name}'] = multiclass_loss.item()
+        
+        if multiclass_losses:
+            avg_multiclass_loss = torch.mean(torch.stack(multiclass_losses))
+            total_loss += avg_multiclass_loss
+            loss_components['avg_multiclass_loss'] = avg_multiclass_loss.item()
+        
+        # Regression losses
+        regression_losses = []
+        for biomarker in self.biomarker_config.continuous_biomarkers:
+            layout = self.tensor_layout[biomarker.name]
+            
+            pred_slice = predictions[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            target_slice = targets[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            
+            loss_fn = self.regression_losses[biomarker.name]
+            regression_loss = loss_fn(pred_slice, target_slice)
+            regression_losses.append(regression_loss)
+            
+            loss_components[f'regression_{biomarker.name}'] = regression_loss.item()
+        
+        if regression_losses:
+            avg_regression_loss = torch.mean(torch.stack(regression_losses))
+            total_loss += avg_regression_loss
+            loss_components['avg_regression_loss'] = avg_regression_loss.item()
+        
+        loss_components['total_loss'] = total_loss.item()
+        
+        return total_loss, loss_components
+
+
+class FlexibleMetricsCalculator:
+    """Calculate comprehensive metrics for flexible multi-task learning"""
+    
+    def __init__(self, biomarker_config: FlexibleBiomarkerConfig):
+        self.biomarker_config = biomarker_config
+        self.tensor_layout = biomarker_config.get_tensor_layout()
+        
+        # Threshold optimization settings from config
+        validation_config = biomarker_config.validation
+        self.threshold_optimization = validation_config.get('threshold_optimization', False)
+        self.optimization_metric = validation_config.get('optimization_metric', 'f1_score')
+        self.per_biomarker_thresholds = validation_config.get('per_biomarker_thresholds', True)
+        self.threshold_range = validation_config.get('threshold_search_range', [0.1, 0.9])
+        self.threshold_steps = validation_config.get('threshold_search_steps', 81)
+        self.fallback_threshold = validation_config.get('fallback_threshold', 0.5)
+        
+        # Store optimal thresholds per biomarker
+        self.optimal_thresholds = {}
+    
+    def find_optimal_threshold(self, pred_probs: np.ndarray, true_labels: np.ndarray, 
+                              metric: str = 'f1_score') -> Tuple[float, float]:
+        """
+        Find optimal threshold for a single biomarker based on specified metric
+        
+        Args:
+            pred_probs: Predicted probabilities [N]
+            true_labels: True binary labels [N]
+            metric: Metric to optimize ('f1_score', 'sensitivity', 'specificity', etc.)
+            
+        Returns:
+            best_threshold: Optimal threshold value
+            best_score: Best metric score achieved
+        """
+        from sklearn.metrics import f1_score, precision_score, recall_score
+        
+        # Create threshold search space
+        thresholds = np.linspace(self.threshold_range[0], self.threshold_range[1], self.threshold_steps)
+        
+        best_threshold = self.fallback_threshold
+        best_score = 0.0
+        
+        for threshold in thresholds:
+            pred_labels = (pred_probs > threshold).astype(int)
+            
+            try:
+                if metric == 'f1_score':
+                    score = f1_score(true_labels, pred_labels, zero_division=0.0)
+                elif metric == 'precision':
+                    score = precision_score(true_labels, pred_labels, zero_division=0.0)
+                elif metric == 'recall' or metric == 'sensitivity':
+                    score = recall_score(true_labels, pred_labels, zero_division=0.0)
+                elif metric == 'specificity':
+                    # Specificity = TN / (TN + FP)
+                    tn = np.sum((pred_labels == 0) & (true_labels == 0))
+                    fp = np.sum((pred_labels == 1) & (true_labels == 0))
+                    score = tn / (tn + fp + 1e-8)
+                elif metric == 'accuracy':
+                    score = (pred_labels == true_labels).mean()
+                else:
+                    # Default to f1_score
+                    score = f1_score(true_labels, pred_labels, zero_division=0.0)
+                
+                if score > best_score:
+                    best_score = score
+                    best_threshold = threshold
+                    
+            except (ValueError, ZeroDivisionError):
+                continue
+        
+        return best_threshold, best_score
+    
+    def optimize_thresholds(self, predictions: torch.Tensor, targets: torch.Tensor) -> Dict[str, float]:
+        """
+        Find optimal thresholds for all binary biomarkers
+        
+        Args:
+            predictions: Model predictions [batch_size, total_output_size]
+            targets: True targets [batch_size, total_output_size]
+            
+        Returns:
+            Dictionary mapping biomarker names to optimal thresholds
+        """
+        # Convert to numpy
+        if isinstance(predictions, torch.Tensor):
+            predictions = predictions.detach().cpu().numpy()
+        if isinstance(targets, torch.Tensor):
+            targets = targets.detach().cpu().numpy()
+        
+        optimal_thresholds = {}
+        
+        for biomarker in self.biomarker_config.binary_biomarkers:
+            layout = self.tensor_layout[biomarker.name]
+            
+            pred_logits = predictions[:, layout.start_idx]
+            pred_probs = 1 / (1 + np.exp(-pred_logits))  # Sigmoid
+            true_labels = targets[:, layout.start_idx].astype(int)
+            
+            # Skip if all labels are the same (no positive or negative examples)
+            if len(np.unique(true_labels)) < 2:
+                optimal_thresholds[biomarker.name] = self.fallback_threshold
+                continue
+            
+            # Find optimal threshold
+            best_threshold, best_score = self.find_optimal_threshold(
+                pred_probs, true_labels, self.optimization_metric
+            )
+            
+            optimal_thresholds[biomarker.name] = best_threshold
+            
+            # Log the optimization result
+            logger.info(
+                "  %s: threshold=%.3f, %s=%.3f",
+                biomarker.name,
+                best_threshold,
+                self.optimization_metric,
+                best_score,
+            )
+        
+        return optimal_thresholds
+    
+    def update_optimal_thresholds(self, predictions: torch.Tensor, targets: torch.Tensor):
+        """Update optimal thresholds based on current predictions and targets"""
+        if self.threshold_optimization:
+            logger.info("Optimizing thresholds...")
+            self.optimal_thresholds = self.optimize_thresholds(predictions, targets)
+        else:
+            # Use fallback threshold for all biomarkers
+            for biomarker in self.biomarker_config.binary_biomarkers:
+                self.optimal_thresholds[biomarker.name] = self.fallback_threshold
+    
+    def calculate_binary_metrics(self, predictions: torch.Tensor, targets: torch.Tensor, 
+                                use_optimal_thresholds: bool = True) -> Dict[str, Dict[str, float]]:
+        """Calculate metrics for binary classification tasks"""
+        metrics = {}
+        
+        # Convert to numpy
+        if isinstance(predictions, torch.Tensor):
+            predictions = predictions.detach().cpu().numpy()
+        if isinstance(targets, torch.Tensor):
+            targets = targets.detach().cpu().numpy()
+        
+        for biomarker in self.biomarker_config.binary_biomarkers:
+            layout = self.tensor_layout[biomarker.name]
+            
+            pred_logits = predictions[:, layout.start_idx]
+            pred_probs = 1 / (1 + np.exp(-pred_logits))  # Sigmoid
+            true_labels = targets[:, layout.start_idx].astype(int)
+            
+            # AUROC (threshold-independent)
+            try:
+                from sklearn.metrics import roc_auc_score
+                auroc = roc_auc_score(true_labels, pred_probs)
+            except (ValueError, ImportError):
+                auroc = 0.0
+            
+            # Get threshold for this biomarker
+            if use_optimal_thresholds and biomarker.name in self.optimal_thresholds:
+                threshold = self.optimal_thresholds[biomarker.name]
+            else:
+                threshold = self.fallback_threshold
+            
+            # Predictions with threshold
+            pred_labels = (pred_probs > threshold).astype(int)
+            
+            # Basic metrics
+            accuracy = (pred_labels == true_labels).mean()
+            
+            # Confusion matrix components
+            true_positives = np.sum((pred_labels == 1) & (true_labels == 1))
+            true_negatives = np.sum((pred_labels == 0) & (true_labels == 0))
+            false_positives = np.sum((pred_labels == 1) & (true_labels == 0))
+            false_negatives = np.sum((pred_labels == 0) & (true_labels == 1))
+            
+            # Sensitivity and Specificity
+            sensitivity = true_positives / (true_positives + false_negatives) if (true_positives + false_negatives) > 0 else 0.0
+            specificity = true_negatives / (true_negatives + false_positives) if (true_negatives + false_positives) > 0 else 0.0
+            
+            # F1 Score
+            try:
+                from sklearn.metrics import f1_score
+                f1 = f1_score(true_labels, pred_labels, zero_division=0.0)
+            except ImportError:
+                precision = true_positives / (true_positives + false_positives) if (true_positives + false_positives) > 0 else 0.0
+                recall = sensitivity
+                f1 = 2 * (precision * recall) / (precision + recall + 1e-8)
+            
+            metrics[biomarker.name] = {
+                'auroc': float(auroc),
+                'accuracy': float(accuracy),
+                'sensitivity': float(sensitivity),
+                'specificity': float(specificity),
+                'f1': float(f1),
+                'threshold': float(threshold),  # Include threshold used
+                'true_positives': int(true_positives),
+                'true_negatives': int(true_negatives),
+                'false_positives': int(false_positives),
+                'false_negatives': int(false_negatives)
+            }
+        
+        return metrics
+    
+    def calculate_multiclass_metrics(self, predictions: torch.Tensor, targets: torch.Tensor) -> Dict[str, Dict[str, Any]]:
+        """Calculate metrics for multiclass classification tasks"""
+        metrics = {}
+        
+        # Convert to numpy
+        if isinstance(predictions, torch.Tensor):
+            predictions = predictions.detach().cpu().numpy()
+        if isinstance(targets, torch.Tensor):
+            targets = targets.detach().cpu().numpy()
+        
+        for biomarker in self.biomarker_config.multiclass_biomarkers:
+            layout = self.tensor_layout[biomarker.name]
+            
+            pred_logits = predictions[:, layout.start_idx:layout.end_idx]
+            # Numerically stable softmax
+            max_logits = np.max(pred_logits, axis=1, keepdims=True)
+            exp_logits = np.exp(pred_logits - max_logits)
+            pred_probs = exp_logits / (np.sum(exp_logits, axis=1, keepdims=True) + 1e-12)
+            target_one_hot = targets[:, layout.start_idx:layout.end_idx]
+            
+            # Get predicted and true classes
+            pred_classes = np.argmax(pred_probs, axis=1)
+            true_classes = np.argmax(target_one_hot, axis=1)
+            
+            # Overall accuracy
+            accuracy = (pred_classes == true_classes).mean()
+            
+            # Multi-class AUROC
+            try:
+                from sklearn.metrics import roc_auc_score
+                auroc = roc_auc_score(target_one_hot, pred_probs, multi_class='ovr', average='macro')
+            except (ValueError, ImportError):
+                auroc = 0.0
+            
+            metrics[biomarker.name] = {
+                'accuracy': float(accuracy),
+                'auroc': float(auroc)
+            }
+        
+        return metrics
+    
+    def calculate_regression_metrics(self, predictions: torch.Tensor, targets: torch.Tensor) -> Dict[str, Dict[str, float]]:
+        """Calculate metrics for regression tasks"""
+        metrics = {}
+        
+        # Convert to numpy
+        if isinstance(predictions, torch.Tensor):
+            predictions = predictions.detach().cpu().numpy()
+        if isinstance(targets, torch.Tensor):
+            targets = targets.detach().cpu().numpy()
+        
+        for biomarker in self.biomarker_config.continuous_biomarkers:
+            layout = self.tensor_layout[biomarker.name]
+            
+            pred_values = predictions[:, layout.start_idx]
+            true_values = targets[:, layout.start_idx]
+            
+            # Denormalize if needed
+            if biomarker.normalization == "min_max":
+                pred_denorm = pred_values * (biomarker.max_value - biomarker.min_value) + biomarker.min_value
+                true_denorm = true_values * (biomarker.max_value - biomarker.min_value) + biomarker.min_value
+            else:
+                pred_denorm = pred_values
+                true_denorm = true_values
+            
+            # Calculate metrics
+            mse = np.mean((pred_denorm - true_denorm) ** 2)
+            mae = np.mean(np.abs(pred_denorm - true_denorm))
+            
+            # R² score
+            ss_res = np.sum((true_denorm - pred_denorm) ** 2)
+            ss_tot = np.sum((true_denorm - np.mean(true_denorm)) ** 2)
+            r2 = 1 - (ss_res / (ss_tot + 1e-8))
+            
+            metrics[biomarker.name] = {
+                'mse': float(mse),
+                'mae': float(mae),
+                'r2': float(r2)
+            }
+        
+        return metrics
+    
+    def calculate_all_metrics(self, predictions: torch.Tensor, targets: torch.Tensor) -> Dict[str, Any]:
+        """Calculate all metrics"""
+        all_metrics = {}
+        
+        # Binary metrics
+        if self.biomarker_config.binary_biomarkers:
+            binary_metrics = self.calculate_binary_metrics(predictions, targets)
+            all_metrics.update(binary_metrics)
+        
+        # Multiclass metrics
+        if self.biomarker_config.multiclass_biomarkers:
+            multiclass_metrics = self.calculate_multiclass_metrics(predictions, targets)
+            all_metrics.update(multiclass_metrics)
+        
+        # Regression metrics
+        if self.biomarker_config.continuous_biomarkers:
+            regression_metrics = self.calculate_regression_metrics(predictions, targets)
+            all_metrics.update(regression_metrics)
+        
+        # Calculate both average and median AUROC for comprehensive monitoring
+        auroc_values = []
+        for biomarker_name, metrics in all_metrics.items():
+            if isinstance(metrics, dict) and 'auroc' in metrics:
+                auroc_values.append(metrics['auroc'])
+        
+        if auroc_values:
+            all_metrics['average_auroc'] = float(np.mean(auroc_values))
+            all_metrics['median_auroc'] = float(np.median(auroc_values))
+        else:
+            all_metrics['average_auroc'] = 0.0
+            all_metrics['median_auroc'] = 0.0
+        
+        return all_metrics
+
+

code/model/gradnorm_loss.py

@@ -0,0 +1,327 @@
+"""
+GradNorm Implementation for Multi-Task Loss Balancing
+Based on "GradNorm: Gradient Normalization for Adaptive Loss Balancing in Deep Multitask Networks"
+Chen et al., 2018 (https://arxiv.org/abs/1711.02257)
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Any, Dict, List, Tuple, Optional
+import numpy as np
+from collections import deque
+import logging
+
+from config.biomarker_config import FlexibleBiomarkerConfig
+from model.flexible_multitask_head import FlexibleMultiTaskLoss
+
+logger = logging.getLogger(__name__)
+
+
+class GradNormLoss(nn.Module):
+    """
+    GradNorm-based multi-task loss balancing.
+    
+    This implementation extends the FlexibleMultiTaskLoss with GradNorm algorithm
+    for automatic loss balancing based on gradient magnitudes.
+    """
+    
+    def __init__(
+        self,
+        biomarker_config: FlexibleBiomarkerConfig,
+        class_weights: Dict[str, float] = None,
+        alpha: float = 0.16,
+        initial_task_loss_average_window: int = 20,
+        update_weights_every: int = 10,
+        normalize_losses: bool = True,
+        restoring_force_factor: float = 0.1
+    ):
+        """
+        Initialize GradNorm loss.
+        
+        Args:
+            biomarker_config: Configuration for biomarkers and tasks
+            class_weights: Initial class weights for individual losses
+            alpha: Restoring force strength (typically 0.12-0.16)
+            initial_task_loss_average_window: Window size for computing initial task loss averages
+            update_weights_every: Update loss weights every N iterations
+            normalize_losses: Whether to normalize individual losses
+            restoring_force_factor: Factor for the restoring force strength
+        """
+        super().__init__()
+        
+        self.biomarker_config = biomarker_config
+        self.alpha = alpha
+        self.update_weights_every = update_weights_every
+        self.normalize_losses = normalize_losses
+        self.restoring_force_factor = restoring_force_factor
+        self.initial_task_loss_average_window = initial_task_loss_average_window
+        
+        # Create the base multi-task loss
+        self.base_loss = FlexibleMultiTaskLoss(biomarker_config, class_weights)
+        
+        # Get task information
+        self.task_names = self._get_task_names()
+        self.num_tasks = len(self.task_names)
+        
+        # Initialize task weights (learnable parameters)
+        initial_weights = torch.ones(self.num_tasks, dtype=torch.float32)
+        self.task_weights = nn.Parameter(initial_weights)
+        
+        # Tracking variables
+        self.step_count = 0
+        self.initial_task_losses = {task: deque(maxlen=initial_task_loss_average_window) 
+                                  for task in self.task_names}
+        self.initial_losses_computed = False
+        self.task_loss_averages = None
+        
+        # For debugging and monitoring
+        self.weight_history = []
+        self.loss_ratio_history = []
+    
+    def to(self, device):
+        """Move GradNorm loss to device."""
+        super().to(device)
+        self.task_weights.data = self.task_weights.data.to(device)
+        if self.task_loss_averages is not None:
+            self.task_loss_averages = self.task_loss_averages.to(device)
+        return self
+        
+    def _get_task_names(self) -> List[str]:
+        """Get list of all task names from biomarker config."""
+        task_names = []
+        
+        # Add binary tasks
+        for biomarker in self.biomarker_config.binary_biomarkers:
+            task_names.append(f"binary_{biomarker.name}")
+        
+        # Add multiclass tasks
+        for biomarker in self.biomarker_config.multiclass_biomarkers:
+            task_names.append(f"multiclass_{biomarker.name}")
+        
+        # Add regression tasks
+        for biomarker in self.biomarker_config.continuous_biomarkers:
+            task_names.append(f"regression_{biomarker.name}")
+        
+        return task_names
+    
+    def _get_task_losses_from_components(self, loss_components: Dict[str, float]) -> torch.Tensor:
+        """Extract individual task losses from loss components dict."""
+        task_losses = []
+        
+        for task_name in self.task_names:
+            if task_name in loss_components:
+                task_losses.append(loss_components[task_name])
+            else:
+                # Handle missing task (shouldn't happen, but safety check)
+                task_losses.append(0.0)
+        
+        return torch.tensor(task_losses, dtype=torch.float32, device=self.task_weights.device)
+    
+    def _get_task_losses_as_tensors(self, predictions: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
+        """Extract individual task losses as tensors (maintaining gradient connection)."""
+        device = predictions.device
+        task_losses = []
+        tensor_layout = self.biomarker_config.get_tensor_layout()
+        
+        # Binary classification losses
+        for biomarker in self.biomarker_config.binary_biomarkers:
+            layout = tensor_layout[biomarker.name]
+            
+            pred_slice = predictions[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            target_slice = targets[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            
+            loss_fn = self.base_loss.binary_losses[biomarker.name]
+            binary_loss = loss_fn(pred_slice, target_slice)
+            task_losses.append(binary_loss)
+        
+        # Multiclass classification losses
+        for biomarker in self.biomarker_config.multiclass_biomarkers:
+            layout = tensor_layout[biomarker.name]
+            
+            pred_slice = predictions[:, layout.start_idx:layout.end_idx]  # [B, num_classes]
+            target_slice = targets[:, layout.start_idx:layout.end_idx]  # [B, num_classes]
+            
+            # Convert one-hot targets to class indices
+            target_indices = torch.argmax(target_slice, dim=1)  # [B]
+            
+            loss_fn = self.base_loss.multiclass_losses[biomarker.name]
+            multiclass_loss = loss_fn(pred_slice, target_indices)
+            task_losses.append(multiclass_loss)
+        
+        # Regression losses
+        for biomarker in self.biomarker_config.continuous_biomarkers:
+            layout = tensor_layout[biomarker.name]
+            
+            pred_slice = predictions[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            target_slice = targets[:, layout.start_idx:layout.end_idx].squeeze(-1)  # [B]
+            
+            loss_fn = self.base_loss.regression_losses[biomarker.name]
+            regression_loss = loss_fn(pred_slice, target_slice)
+            task_losses.append(regression_loss)
+        
+        return torch.stack(task_losses)
+    
+    def _compute_initial_task_losses(self, task_losses: torch.Tensor):
+        """Collect initial task losses for computing averages."""
+        task_losses_cpu = task_losses.detach().cpu().numpy()
+        
+        for i, task_name in enumerate(self.task_names):
+            self.initial_task_losses[task_name].append(task_losses_cpu[i])
+        
+        # Check if we have enough samples to compute averages
+        min_samples = min(len(losses) for losses in self.initial_task_losses.values())
+        if min_samples >= self.initial_task_loss_average_window:
+            self.task_loss_averages = torch.tensor([
+                np.mean(self.initial_task_losses[task_name])
+                for task_name in self.task_names
+            ], dtype=torch.float32, device=self.task_weights.device)
+            
+            self.initial_losses_computed = True
+            logger.info(
+                "GradNorm: Initial task loss averages computed: %s",
+                dict(zip(self.task_names, self.task_loss_averages.cpu().numpy())),
+            )
+    
+    def _update_task_weights(self, model: nn.Module, task_losses: torch.Tensor):
+        """Update task weights using simplified GradNorm algorithm."""
+        if not self.initial_losses_computed:
+            return
+        
+        device = self.task_weights.device
+        
+        # Simplified approach: update weights based on loss ratios without gradient computation
+        # This avoids the gradient computation issues while still providing adaptive balancing
+        
+        # Compute relative inverse training rates
+        task_loss_ratios = task_losses / self.task_loss_averages
+        relative_inverse_training_rates = task_loss_ratios / torch.mean(task_loss_ratios)
+        
+        # Update weights based on relative training rates
+        # Higher loss ratio -> higher weight (more attention to struggling tasks)
+        # Apply restoring force based on relative training rates
+        weight_updates = (relative_inverse_training_rates ** self.alpha) - 1.0
+        self.task_weights.data += self.restoring_force_factor * weight_updates
+        
+        # Renormalize weights to prevent them from growing unboundedly
+        self.task_weights.data = F.softmax(self.task_weights.data, dim=0) * self.num_tasks
+        
+        # Store for monitoring
+        self.weight_history.append(self.task_weights.data.detach().cpu().numpy().copy())
+        self.loss_ratio_history.append(relative_inverse_training_rates.detach().cpu().numpy().copy())
+        
+        if len(self.weight_history) % 50 == 0:  # Print every 50 updates
+            logger.info(
+                "GradNorm Step %s: Weights = %s",
+                self.step_count,
+                dict(zip(self.task_names, self.task_weights.data.cpu().numpy())),
+            )
+    
+    def forward(self, predictions: torch.Tensor, targets: torch.Tensor, 
+                model: Optional[nn.Module] = None) -> Tuple[torch.Tensor, Dict[str, float]]:
+        """
+        Forward pass with GradNorm loss balancing.
+        
+        Args:
+            predictions: Model predictions
+            targets: Ground truth targets
+            model: The model (needed for gradient computation)
+            
+        Returns:
+            total_loss: Balanced total loss
+            loss_dict: Dictionary with loss components and weights
+        """
+        # Get individual task losses from base loss
+        base_total_loss, loss_components = self.base_loss(predictions, targets)
+        
+        # Extract task losses as tensors (maintaining gradient connection)
+        task_losses = self._get_task_losses_as_tensors(predictions, targets)
+        
+        # Collect initial losses if not yet computed
+        if not self.initial_losses_computed:
+            self._compute_initial_task_losses(task_losses)
+        
+        # Update task weights using GradNorm (if model is provided and enough steps have passed)
+        if (model is not None and 
+            self.initial_losses_computed and 
+            self.step_count % self.update_weights_every == 0 and
+            self.step_count > 0):
+            self._update_task_weights(model, task_losses)
+        
+        # Compute weighted total loss
+        if self.initial_losses_computed:
+            # Normalize task losses if requested
+            if self.normalize_losses:
+                normalized_task_losses = task_losses / self.task_loss_averages
+                weighted_losses = self.task_weights * normalized_task_losses
+            else:
+                weighted_losses = self.task_weights * task_losses
+            
+            total_loss = torch.sum(weighted_losses)
+        else:
+            # Use equal weighting during initial phase
+            total_loss = torch.sum(task_losses)
+        
+        # Update loss components with weights
+        loss_components['total_loss'] = total_loss.item()
+        
+        # Add weight information to loss components
+        if self.initial_losses_computed:
+            for i, task_name in enumerate(self.task_names):
+                loss_components[f'weight_{task_name}'] = self.task_weights[i].item()
+        
+        self.step_count += 1
+        
+        return total_loss, loss_components
+    
+    def get_task_weights(self) -> Dict[str, float]:
+        """Get current task weights as dictionary."""
+        if not self.initial_losses_computed:
+            return {task: 1.0 for task in self.task_names}
+        
+        return dict(zip(self.task_names, self.task_weights.data.cpu().numpy()))
+    
+    def get_weight_history(self) -> List[Dict[str, float]]:
+        """Get history of task weights for analysis."""
+        history = []
+        for weights in self.weight_history:
+            history.append(dict(zip(self.task_names, weights)))
+        return history
+    
+    def reset_weights(self):
+        """Reset task weights to uniform distribution."""
+        with torch.no_grad():
+            self.task_weights.data.fill_(1.0)
+        self.initial_losses_computed = False
+        self.step_count = 0
+        self.weight_history.clear()
+        self.loss_ratio_history.clear()
+        for task_losses in self.initial_task_losses.values():
+            task_losses.clear()
+
+
+class GradNormTrainer:
+    """
+    Utility class to help integrate GradNorm with existing training loops.
+    """
+    
+    def __init__(self, gradnorm_loss: GradNormLoss):
+        self.gradnorm_loss = gradnorm_loss
+        
+    def compute_loss(self, model: nn.Module, predictions: torch.Tensor, 
+                    targets: torch.Tensor) -> Tuple[torch.Tensor, Dict[str, float]]:
+        """
+        Compute loss using GradNorm.
+        
+        This method should replace the standard criterion(predictions, targets) call.
+        """
+        return self.gradnorm_loss(predictions, targets, model)
+    
+    def get_training_stats(self) -> Dict[str, Any]:
+        """Get training statistics for logging."""
+        return {
+            'task_weights': self.gradnorm_loss.get_task_weights(),
+            'step_count': self.gradnorm_loss.step_count,
+            'initial_losses_computed': self.gradnorm_loss.initial_losses_computed,
+            'num_tasks': self.gradnorm_loss.num_tasks
+        }

code/model/model_factory.py

@@ -0,0 +1,355 @@
+"""
+Model Factory for public architectures used in this release.
+"""
+
+from pathlib import Path
+
+import timm
+import torch
+import torch.nn as nn
+import torchvision.models as models
+from torchvision.models import (
+    DenseNet121_Weights,
+    EfficientNet_B0_Weights,
+    ResNet18_Weights,
+    ResNet34_Weights,
+    ResNet50_Weights,
+    Swin_B_Weights,
+)
+from config.experiment_config import MODEL_DEFAULTS
+
+
+
+class MultiTaskHead(nn.Module):
+    """Legacy fallback head used when biomarker_config is not provided."""
+
+    def __init__(self, input_dim, num_binary_tasks=7, num_calcium_classes=4, num_regression_tasks=2, dropout=0.1):
+        super().__init__()
+        self.shared_layers = nn.Sequential(
+            nn.Linear(input_dim, 512),
+            nn.ReLU(inplace=True),
+            nn.Dropout(dropout),
+            nn.BatchNorm1d(512),
+        )
+        self.binary_head = nn.Linear(512, num_binary_tasks)
+        self.calcium_head = nn.Linear(512, num_calcium_classes)
+        self.regression_head = nn.Linear(512, num_regression_tasks)
+
+    def forward(self, x):
+        shared = self.shared_layers(x)
+        binary_out = self.binary_head(shared)
+        calcium_out = self.calcium_head(shared)
+        regression_out = self.regression_head(shared)
+        return torch.cat([binary_out, calcium_out, regression_out], dim=1)
+
+
+class ModelFactory:
+    """Factory class for supported public model architectures."""
+
+    SUPPORTED_ARCHITECTURES = tuple(MODEL_DEFAULTS.keys())
+
+    @staticmethod
+    def create_model(
+        architecture,
+        num_classes=13,
+        pretrained_weights=None,
+        fine_tuning_strategy="full",
+        dropout=0.1,
+        biomarker_config=None,
+        single_target_strategy=None,
+        target_feature_dim=None,
+        single_target_output_dim=None,
+        **kwargs,
+    ):
+        """Create model based on architecture specification."""
+        if single_target_output_dim is not None:
+            target_feature_dim = single_target_output_dim
+
+        if architecture == "ResNet-18":
+            return ModelFactory._create_resnet18(
+                num_classes,
+                pretrained_weights,
+                fine_tuning_strategy,
+                dropout,
+                biomarker_config,
+                single_target_strategy,
+                target_feature_dim,
+            )
+        if architecture == "ResNet-34":
+            return ModelFactory._create_resnet34(
+                num_classes,
+                pretrained_weights,
+                fine_tuning_strategy,
+                dropout,
+                biomarker_config,
+                single_target_strategy,
+                target_feature_dim,
+            )
+        if architecture == "DenseNet-121":
+            return ModelFactory._create_densenet121(
+                num_classes,
+                pretrained_weights,
+                fine_tuning_strategy,
+                dropout,
+                biomarker_config,
+                single_target_strategy,
+                target_feature_dim,
+            )
+        if architecture == "EfficientNet-B0":
+            return ModelFactory._create_efficientnet_b0(
+                num_classes,
+                pretrained_weights,
+                fine_tuning_strategy,
+                dropout,
+                biomarker_config,
+                single_target_strategy,
+                target_feature_dim,
+            )
+        if architecture == "ViT-Small (DINOv2)":
+            return ModelFactory._create_dinov2_vit(
+                architecture,
+                num_classes,
+                fine_tuning_strategy,
+                dropout,
+                biomarker_config,
+                single_target_strategy,
+                target_feature_dim,
+            )
+        if architecture == "Swin Transformer-Base":
+            return ModelFactory._create_swin_base(
+                num_classes,
+                pretrained_weights,
+                fine_tuning_strategy,
+                dropout,
+                biomarker_config,
+                single_target_strategy,
+                target_feature_dim,
+            )
+        if architecture == "ResNet-50 (RadImageNet)":
+            return ModelFactory._create_resnet50_radimgnet(
+                num_classes,
+                fine_tuning_strategy,
+                dropout,
+                biomarker_config,
+                single_target_strategy,
+                target_feature_dim,
+            )
+
+        raise ValueError(
+            f"Unsupported architecture: {architecture}. "
+            f"Supported: {list(ModelFactory.SUPPORTED_ARCHITECTURES)}"
+        )
+
+    @staticmethod
+    def _create_multitask_head(feature_dim, dropout, biomarker_config, head_type="flexible", single_target_strategy=None, target_feature_dim=None):
+        if biomarker_config is not None:
+            if head_type == "linear_probe":
+                from .flexible_multitask_head import LinearProbeMultiTaskHead
+
+                return LinearProbeMultiTaskHead(
+                    feature_dim,
+                    biomarker_config,
+                    dropout=dropout,
+                    single_target_strategy=single_target_strategy,
+                    target_feature_dim=target_feature_dim,
+                )
+            from .flexible_multitask_head import FlexibleMultiTaskHead
+
+            return FlexibleMultiTaskHead(
+                feature_dim,
+                biomarker_config,
+                dropout=dropout,
+                single_target_strategy=single_target_strategy,
+                target_feature_dim=target_feature_dim,
+            )
+        return MultiTaskHead(feature_dim, dropout=dropout)
+
+    @staticmethod
+    def _freeze_for_linear_probe(model, head_module):
+        for param in model.parameters():
+            param.requires_grad = False
+        for param in head_module.parameters():
+            param.requires_grad = True
+
+    @staticmethod
+    def _create_resnet18(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None):
+        head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible"
+        if pretrained_weights == "ImageNet":
+            model = models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)
+        else:
+            model = models.resnet18(weights=None)
+            model.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
+
+        feature_dim = model.fc.in_features
+        model.fc = ModelFactory._create_multitask_head(
+            feature_dim, dropout, biomarker_config, head_type, single_target_strategy, target_feature_dim
+        )
+        if fine_tuning_strategy == "linear_probe":
+            ModelFactory._freeze_for_linear_probe(model, model.fc)
+        return model
+
+    @staticmethod
+    def _create_resnet34(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None):
+        head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible"
+        if pretrained_weights == "ImageNet":
+            model = models.resnet34(weights=ResNet34_Weights.IMAGENET1K_V1)
+        else:
+            model = models.resnet34(weights=None)
+            model.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
+
+        feature_dim = model.fc.in_features
+        model.fc = ModelFactory._create_multitask_head(
+            feature_dim, dropout, biomarker_config, head_type, single_target_strategy, target_feature_dim
+        )
+        if fine_tuning_strategy == "linear_probe":
+            ModelFactory._freeze_for_linear_probe(model, model.fc)
+        return model
+
+    @staticmethod
+    def _create_densenet121(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config=None, single_target_strategy=None, target_feature_dim=None):
+        head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible"
+        if pretrained_weights == "ImageNet":
+            model = models.densenet121(weights=DenseNet121_Weights.IMAGENET1K_V1)
+        else:
+            model = models.densenet121(weights=None)
+        feature_dim = model.classifier.in_features
+        model.classifier = ModelFactory._create_multitask_head(
+            feature_dim,
+            dropout,
+            biomarker_config,
+            head_type=head_type,
+            single_target_strategy=single_target_strategy,
+            target_feature_dim=target_feature_dim,
+        )
+        if fine_tuning_strategy == "linear_probe":
+            ModelFactory._freeze_for_linear_probe(model, model.classifier)
+        return model
+
+    @staticmethod
+    def _create_efficientnet_b0(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config=None, single_target_strategy=None, target_feature_dim=None):
+        head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible"
+        if pretrained_weights == "ImageNet":
+            model = models.efficientnet_b0(weights=EfficientNet_B0_Weights.IMAGENET1K_V1)
+        else:
+            model = models.efficientnet_b0(weights=None)
+        feature_dim = model.classifier[1].in_features
+        model.classifier = ModelFactory._create_multitask_head(
+            feature_dim,
+            dropout,
+            biomarker_config,
+            head_type=head_type,
+            single_target_strategy=single_target_strategy,
+            target_feature_dim=target_feature_dim,
+        )
+        if fine_tuning_strategy == "linear_probe":
+            ModelFactory._freeze_for_linear_probe(model, model.classifier)
+        return model
+
+    @staticmethod
+    def _create_dinov2_vit(architecture, num_classes, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None):
+        head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible"
+        model = timm.create_model("vit_small_patch14_dinov2", pretrained=True, num_classes=0, img_size=256)
+        feature_dim = model.num_features
+        model.head = ModelFactory._create_multitask_head(
+            feature_dim,
+            dropout,
+            biomarker_config,
+            head_type=head_type,
+            single_target_strategy=single_target_strategy,
+            target_feature_dim=target_feature_dim,
+        )
+        if fine_tuning_strategy == "linear_probe":
+            ModelFactory._freeze_for_linear_probe(model, model.head)
+        return model
+
+    @staticmethod
+    def _create_swin_base(num_classes, pretrained_weights, fine_tuning_strategy, dropout, biomarker_config=None, single_target_strategy=None, target_feature_dim=None):
+        head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible"
+        if pretrained_weights == "ImageNet-22K":
+            model = models.swin_b(weights=Swin_B_Weights.IMAGENET1K_V1)
+        else:
+            model = models.swin_b(weights=None)
+            model.features[0][0] = nn.Conv2d(1, 128, kernel_size=4, stride=4)
+        feature_dim = model.head.in_features
+        model.head = ModelFactory._create_multitask_head(
+            feature_dim,
+            dropout,
+            biomarker_config,
+            head_type=head_type,
+            single_target_strategy=single_target_strategy,
+            target_feature_dim=target_feature_dim,
+        )
+        if fine_tuning_strategy == "linear_probe":
+            ModelFactory._freeze_for_linear_probe(model, model.head)
+        return model
+
+    @staticmethod
+    def _create_resnet50_radimgnet(num_classes, fine_tuning_strategy, dropout, biomarker_config, single_target_strategy=None, target_feature_dim=None):
+        head_type = "linear_probe" if fine_tuning_strategy == "linear_probe" else "flexible"
+        ckpt_path = (
+            Path(__file__).resolve().parents[1]
+            / "radimagenet_ckpt"
+            / "resnet50"
+            / "ResNet50_RadImageNet.pt"
+        )
+        try:
+            if ckpt_path.exists():
+                model = models.resnet50(weights=None)
+                checkpoint = torch.load(str(ckpt_path), map_location="cpu")
+                state_dict = checkpoint.get("model", checkpoint.get("state_dict", checkpoint))
+                model_state_dict = model.state_dict()
+                filtered_state_dict = {}
+                for key, value in state_dict.items():
+                    if key.startswith("fc.") or key.startswith("classifier."):
+                        continue
+                    mapped_key = key
+                    if key.startswith("backbone."):
+                        mapped_key = key[9:]
+                        if mapped_key.startswith("4."):
+                            mapped_key = "layer1." + mapped_key[2:]
+                        elif mapped_key.startswith("5."):
+                            mapped_key = "layer2." + mapped_key[2:]
+                        elif mapped_key.startswith("6."):
+                            mapped_key = "layer3." + mapped_key[2:]
+                        elif mapped_key.startswith("7."):
+                            mapped_key = "layer4." + mapped_key[2:]
+                        elif mapped_key.startswith("0."):
+                            mapped_key = "conv1." + mapped_key[2:]
+                        elif mapped_key.startswith("1."):
+                            mapped_key = "bn1." + mapped_key[2:]
+                    elif key.startswith("features."):
+                        mapped_key = key[9:]
+                    if mapped_key in model_state_dict:
+                        filtered_state_dict[mapped_key] = value
+                model.load_state_dict(filtered_state_dict, strict=False)
+            else:
+                model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)
+        except Exception:
+            model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)
+
+        feature_dim = model.fc.in_features
+        model.fc = ModelFactory._create_multitask_head(
+            feature_dim,
+            dropout,
+            biomarker_config,
+            head_type=head_type,
+            single_target_strategy=single_target_strategy,
+            target_feature_dim=target_feature_dim,
+        )
+        if fine_tuning_strategy == "linear_probe":
+            ModelFactory._freeze_for_linear_probe(model, model.fc)
+        return model
+
+
+def get_model_memory_requirement(architecture):
+    """Get expected GPU memory requirement for supported public architectures."""
+    memory_map = {
+        "ResNet-18": "4-6GB",
+        "ResNet-34": "6-8GB",
+        "DenseNet-121": "8-10GB",
+        "EfficientNet-B0": "6-8GB",
+        "ViT-Small (DINOv2)": "8-10GB",
+        "Swin Transformer-Base": "12-16GB",
+        "ResNet-50 (RadImageNet)": "6-8GB",
+    }
+    return memory_map.get(architecture, "Unknown")

code/model/single_target_strategies.py

@@ -0,0 +1,281 @@
+"""
+Single Target Strategy Implementations
+Handles different feature extraction strategies for single-target classification
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from enum import Enum
+from typing import Union, Tuple, Optional
+
+
+class SingleTargetStrategy(Enum):
+    """Enumeration of single-target classification strategies"""
+    DIRECT_CLASSIFICATION_HEAD = "Direct classification head"
+    CLS_TOKEN_CLASSIFICATION = "CLS token classification"
+    GLOBAL_AVERAGE_POOLING = "Global average pooling"
+
+
+class FeatureExtractor(nn.Module):
+    """Base class for feature extraction strategies"""
+    
+    def __init__(self, strategy: SingleTargetStrategy):
+        super().__init__()
+        self.strategy = strategy
+    
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """Extract features based on the strategy"""
+        raise NotImplementedError
+
+
+class DirectClassificationHeadExtractor(FeatureExtractor):
+    """
+    Direct classification head strategy for CNN-based models
+    Uses global average pooling followed by classification head
+    """
+    
+    def __init__(self, input_dim: int, feature_dim: int = 512, dropout: float = 0.1):
+        super().__init__(SingleTargetStrategy.DIRECT_CLASSIFICATION_HEAD)
+        
+        # Global average pooling for spatial features
+        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
+        
+        # Feature processing layers
+        self.feature_processor = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(input_dim, feature_dim),
+            nn.ReLU(inplace=True),
+            nn.Dropout(dropout),
+            nn.BatchNorm1d(feature_dim)
+        )
+        
+        self.output_dim = feature_dim
+    
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Extract features using direct classification head approach
+        
+        Args:
+            x: Input features [B, C, H, W] (spatial features from CNN) or [B, input_dim] (flattened features)
+            
+        Returns:
+            Processed features [B, feature_dim]
+        """
+        # Check if input is spatial (4D) or flattened (2D)
+        if x.dim() == 4:
+            # Spatial features: apply global average pooling first
+            pooled = self.global_pool(x)  # [B, C, 1, 1]
+            features = self.feature_processor(pooled)  # [B, feature_dim]
+        elif x.dim() == 2:
+            # Flattened features: skip global pooling, go directly to feature processing
+            # But we need to adjust the input dimension for the linear layer
+            # The input_dim in the constructor was for spatial features, but now we have flattened features
+            # We need to create a new feature processor for the flattened input
+            if not hasattr(self, 'flattened_processor'):
+                # Create a new processor for flattened features
+                self.flattened_processor = nn.Sequential(
+                    nn.Linear(x.size(1), self.output_dim),  # x.size(1) is the actual flattened dimension
+                    nn.ReLU(inplace=True),
+                    nn.Dropout(self.feature_processor[3].p),  # Use same dropout rate
+                    nn.LayerNorm(self.output_dim)  # Use LayerNorm instead of BatchNorm to avoid single-sample issues
+                )
+                # Move to the same device as the input tensor
+                self.flattened_processor = self.flattened_processor.to(x.device)
+            features = self.flattened_processor(x)  # [B, feature_dim]
+        else:
+            raise ValueError(f"Expected 2D or 4D input tensor, got {x.dim()}D tensor with shape {x.shape}")
+        
+        return features
+
+
+class CLSTokenClassificationExtractor(FeatureExtractor):
+    """
+    CLS token classification strategy for Transformer-based models
+    Extracts the CLS token from transformer output
+    """
+    
+    def __init__(self, feature_dim: int = 768, dropout: float = 0.1):
+        super().__init__(SingleTargetStrategy.CLS_TOKEN_CLASSIFICATION)
+        
+        # Feature processing for CLS token
+        self.feature_processor = nn.Sequential(
+            nn.Linear(feature_dim, feature_dim),
+            nn.ReLU(inplace=True),
+            nn.Dropout(dropout),
+            nn.LayerNorm(feature_dim)
+        )
+        
+        self.output_dim = feature_dim
+    
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Extract CLS token features from transformer output
+        
+        Args:
+            x: Transformer output [B, seq_len, feature_dim] or [B, feature_dim]
+            
+        Returns:
+            CLS token features [B, feature_dim]
+        """
+        # Handle different input shapes
+        if x.dim() == 3:  # [B, seq_len, feature_dim]
+            # Extract CLS token (first token)
+            cls_token = x[:, 0, :]  # [B, feature_dim]
+        elif x.dim() == 2:  # [B, feature_dim] - already extracted
+            cls_token = x
+        else:
+            raise ValueError(f"Unexpected input shape: {x.shape}")
+        
+        # Process CLS token features
+        features = self.feature_processor(cls_token)  # [B, feature_dim]
+        
+        return features
+
+
+class GlobalAveragePoolingExtractor(FeatureExtractor):
+    """
+    Global average pooling strategy for models with spatial feature maps
+    Used for VAE encoders and other models that output spatial features
+    """
+    
+    def __init__(self, input_dim: int, feature_dim: int = 512, dropout: float = 0.1):
+        super().__init__(SingleTargetStrategy.GLOBAL_AVERAGE_POOLING)
+        
+        # Global average pooling
+        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))
+        
+        # Feature processing layers
+        self.feature_processor = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(input_dim, feature_dim),
+            nn.ReLU(inplace=True),
+            nn.Dropout(dropout),
+            nn.BatchNorm1d(feature_dim)
+        )
+        
+        self.output_dim = feature_dim
+    
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Extract features using global average pooling
+        
+        Args:
+            x: Input features [B, C, H, W] (spatial features)
+            
+        Returns:
+            Processed features [B, feature_dim]
+        """
+        # Apply global average pooling
+        pooled = self.global_pool(x)  # [B, C, 1, 1]
+        
+        # Process through feature layers
+        features = self.feature_processor(pooled)  # [B, feature_dim]
+        
+        return features
+
+
+def create_feature_extractor(
+    strategy: Union[str, SingleTargetStrategy], 
+    input_dim: int, 
+    feature_dim: int = 512, 
+    dropout: float = 0.1
+) -> FeatureExtractor:
+    """
+    Factory function to create appropriate feature extractor
+    
+    Args:
+        strategy: Single-target strategy (string or enum)
+        input_dim: Input feature dimension
+        feature_dim: Output feature dimension
+        dropout: Dropout rate
+        
+    Returns:
+        Appropriate FeatureExtractor instance
+    """
+    # Convert string to enum if needed
+    if isinstance(strategy, str):
+        strategy = SingleTargetStrategy(strategy)
+    
+    if strategy == SingleTargetStrategy.DIRECT_CLASSIFICATION_HEAD:
+        return DirectClassificationHeadExtractor(input_dim, feature_dim, dropout)
+    
+    elif strategy == SingleTargetStrategy.CLS_TOKEN_CLASSIFICATION:
+        return CLSTokenClassificationExtractor(feature_dim, dropout)
+    
+    elif strategy == SingleTargetStrategy.GLOBAL_AVERAGE_POOLING:
+        return GlobalAveragePoolingExtractor(input_dim, feature_dim, dropout)
+    
+    else:
+        raise ValueError(f"Unknown single-target strategy: {strategy}")
+
+
+def extract_features_from_model_output(
+    model_output: torch.Tensor, 
+    strategy: Union[str, SingleTargetStrategy],
+    input_dim: Optional[int] = None,
+    feature_dim: int = 512,
+    dropout: float = 0.1
+) -> torch.Tensor:
+    """
+    Extract features from model output based on strategy
+    
+    Args:
+        model_output: Raw output from backbone model
+        strategy: Single-target strategy to use
+        input_dim: Input dimension (required for some strategies)
+        feature_dim: Output feature dimension
+        dropout: Dropout rate
+        
+    Returns:
+        Extracted features [B, feature_dim]
+    """
+    # Convert string to enum if needed
+    if isinstance(strategy, str):
+        strategy = SingleTargetStrategy(strategy)
+    
+    if strategy == SingleTargetStrategy.DIRECT_CLASSIFICATION_HEAD:
+        if input_dim is None:
+            raise ValueError("input_dim required for DIRECT_CLASSIFICATION_HEAD strategy")
+        extractor = DirectClassificationHeadExtractor(input_dim, feature_dim, dropout)
+        return extractor(model_output)
+    
+    elif strategy == SingleTargetStrategy.CLS_TOKEN_CLASSIFICATION:
+        extractor = CLSTokenClassificationExtractor(feature_dim, dropout)
+        return extractor(model_output)
+    
+    elif strategy == SingleTargetStrategy.GLOBAL_AVERAGE_POOLING:
+        if input_dim is None:
+            raise ValueError("input_dim required for GLOBAL_AVERAGE_POOLING strategy")
+        extractor = GlobalAveragePoolingExtractor(input_dim, feature_dim, dropout)
+        return extractor(model_output)
+    
+    else:
+        raise ValueError(f"Unknown single-target strategy: {strategy}")
+
+
+# Strategy mapping from config string values to enum values
+STRATEGY_MAPPING = {
+    "Direct classification head": SingleTargetStrategy.DIRECT_CLASSIFICATION_HEAD,
+    "CLS token classification": SingleTargetStrategy.CLS_TOKEN_CLASSIFICATION,
+    "Global average pooling": SingleTargetStrategy.GLOBAL_AVERAGE_POOLING,
+}
+
+
+def get_strategy_from_name(strategy_name: str) -> SingleTargetStrategy:
+    """
+    Convert strategy string value to SingleTargetStrategy enum.
+    
+    Args:
+        strategy_name: Strategy string from config/checkpoint
+        
+    Returns:
+        SingleTargetStrategy enum value
+    """
+    if strategy_name not in STRATEGY_MAPPING:
+        raise ValueError(
+            f"Unknown strategy: {strategy_name}. Available: {list(STRATEGY_MAPPING.keys())}"
+        )
+    
+    return STRATEGY_MAPPING[strategy_name]
+

code/requirements.txt

@@ -0,0 +1,32 @@
+# Requirements for AbdCTBench training and testing
+# Core ML libraries
+torch>=1.12.0
+torchvision>=0.13.0
+timm>=0.9.0
+transformers>=4.20.0
+diffusers>=0.35.0
+
+# Data handling
+pandas>=1.5.0
+numpy>=1.21.0
+scikit-learn>=1.1.0
+Pillow>=9.0.0
+
+# Logging and visualization
+tensorboard>=2.10.0
+tqdm>=4.64.0
+safetensors>=0.4.0
+
+# Medical imaging (optional, for future enhancements)
+# nibabel>=4.0.0
+# pydicom>=2.3.0
+
+# Development tools
+pytest>=7.0.0
+black>=22.0.0
+flake8>=5.0.0
+
+# Additional utilities
+pyyaml>=6.0
+matplotlib>=3.5.0
+seaborn>=0.11.0

code/test.py

@@ -0,0 +1,939 @@
+"""
+Flexible Multi-Task Testing Script
+Supports any biomarker configuration and model architecture
+"""
+
+import os
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from torchvision import transforms
+from argparse import ArgumentParser
+from tqdm import tqdm
+import numpy as np
+import json
+from typing import Dict, Any, List, Tuple
+
+from dataset import ClassifierDataset, PredictionDataset
+from model.model_factory import ModelFactory
+from model.flexible_multitask_head import FlexibleMetricsCalculator
+from config.biomarker_config import FlexibleBiomarkerConfig
+from config.experiment_config import ExperimentConfig, DEFAULT_AUGMENTATIONS
+from sklearn.metrics import roc_auc_score, average_precision_score, mean_absolute_error, mean_squared_error, r2_score
+from sklearn.exceptions import UndefinedMetricWarning
+import warnings
+warnings.filterwarnings("ignore", category=UndefinedMetricWarning)
+
+try:
+    from safetensors.torch import load_file as safetensors_load_file
+except ImportError:
+    safetensors_load_file = None
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+def arg_parse():
+    parser = ArgumentParser(description='Flexible Multi-Task Testing')
+    parser.add_argument('--data_dir', required=True, help='Directory with test data')
+    parser.add_argument(
+        '--checkpoint_path',
+        required=True,
+        help='Path to model checkpoint (.pth/.pt or .safetensors).'
+    )
+    parser.add_argument('--biomarker_config', required=True, help='Path to biomarker configuration file (YAML or JSON)')
+    parser.add_argument('--output_dir', default='test_results', help='Output directory for results')
+    parser.add_argument('--size', default=256, type=int, help='Image size')
+    parser.add_argument('--only_pred', action='store_true', help='Only generate predictions (no ground truth evaluation)')
+    parser.add_argument('--batch_size', default=16, type=int, help='Batch size for inference')
+    parser.add_argument('--save_predictions', action='store_true', help='Save individual predictions to CSV')
+    parser.add_argument('--save_metrics', action='store_true', help='Save detailed metrics to JSON file')
+    parser.add_argument('--use_val_for_thresholds', action='store_true', 
+                       help='Use validation set for threshold optimization (default: use same data_dir)')
+    parser.add_argument('--val_data_dir', help='Path to validation data directory (if different from data_dir)')
+    parser.add_argument('--test_csv', default='test.csv', help='CSV file to use for testing (default: test.csv)')
+    parser.add_argument(
+        '--legacy_checkpoint_compat',
+        action='store_true',
+        help='Enable compatibility loading for older checkpoint key layouts.'
+    )
+    return parser.parse_args()
+
+def load_checkpoint(checkpoint_path: str, legacy_compat: bool = False) -> Dict[str, Any]:
+    """Load checkpoint in current format, optionally with legacy compatibility."""
+    if not os.path.exists(checkpoint_path):
+        raise FileNotFoundError(f"Checkpoint not found: {checkpoint_path}")
+
+    print(f"Loading checkpoint from: {checkpoint_path}")
+    checkpoint_ext = os.path.splitext(checkpoint_path)[1].lower()
+
+    if checkpoint_ext == ".safetensors":
+        if safetensors_load_file is None:
+            raise ImportError(
+                "safetensors is required to load .safetensors checkpoints. "
+                "Install with: pip install safetensors"
+            )
+
+        model_state_dict = safetensors_load_file(checkpoint_path, device="cpu")
+        checkpoint_dir = os.path.dirname(checkpoint_path)
+        config_path = os.path.join(checkpoint_dir, "config.json")
+        thresholds_path = os.path.join(checkpoint_dir, "optimal_thresholds.json")
+
+        config = {}
+        if os.path.exists(config_path):
+            with open(config_path, "r") as f:
+                config = json.load(f)
+        else:
+            print(f"Warning: no config.json found next to safetensors file: {config_path}")
+
+        optimal_thresholds = {}
+        if os.path.exists(thresholds_path):
+            with open(thresholds_path, "r") as f:
+                optimal_thresholds = json.load(f)
+
+        checkpoint = {
+            "model_state_dict": model_state_dict,
+            "config": config,
+            "optimal_thresholds": optimal_thresholds,
+        }
+    else:
+        checkpoint = torch.load(checkpoint_path, map_location='cpu', weights_only=False)
+
+    if legacy_compat and "model_state_dict" not in checkpoint and "state_dict" in checkpoint:
+        checkpoint = {
+            "model_state_dict": checkpoint["state_dict"],
+            "config": checkpoint.get("config", {}),
+            "epoch": checkpoint.get("epoch", 0),
+            "val_metrics": checkpoint.get("val_metrics", {}),
+        }
+
+    required_keys = ["model_state_dict", "config"]
+    missing = [k for k in required_keys if k not in checkpoint]
+    if missing:
+        raise ValueError(
+            f"Checkpoint is missing required keys: {missing}. "
+            "Please use a checkpoint produced by the current train.py pipeline."
+        )
+
+    return checkpoint
+
+
+def _remap_legacy_state_dict_keys(state_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Apply lightweight key remapping for common legacy checkpoint layouts."""
+    remapped = {}
+    for key, value in state_dict.items():
+        new_key = key
+        if new_key.startswith("module."):
+            new_key = new_key[len("module."):]
+        if new_key.startswith("resnet34.fc."):
+            new_key = "fc." + new_key[len("resnet34.fc."):]
+        elif new_key.startswith("resnet18.fc."):
+            new_key = "fc." + new_key[len("resnet18.fc."):]
+        elif new_key.startswith("resnet50.fc."):
+            new_key = "fc." + new_key[len("resnet50.fc."):]
+        remapped[new_key] = value
+    return remapped
+
+
+def _materialize_lazy_modules_from_state_dict(
+    model: torch.nn.Module,
+    state_dict: Dict[str, Any],
+    dropout: float,
+) -> None:
+    """
+    Materialize lazily-created modules (e.g., flattened_processor) before load_state_dict.
+    """
+    weight_key = "classifier.feature_extractor.flattened_processor.0.weight"
+    if (
+        weight_key in state_dict
+        and hasattr(model, "classifier")
+        and hasattr(model.classifier, "feature_extractor")
+        and not hasattr(model.classifier.feature_extractor, "flattened_processor")
+    ):
+        linear_weight = state_dict[weight_key]
+        out_dim, in_dim = linear_weight.shape
+        model.classifier.feature_extractor.flattened_processor = torch.nn.Sequential(
+            torch.nn.Linear(in_dim, out_dim),
+            torch.nn.ReLU(inplace=True),
+            torch.nn.Dropout(dropout),
+            torch.nn.LayerNorm(out_dim),
+        )
+
+
+def create_model_from_checkpoint(
+    checkpoint: Dict[str, Any],
+    biomarker_config: FlexibleBiomarkerConfig,
+    legacy_compat: bool = False
+) -> Tuple[torch.nn.Module, ExperimentConfig]:
+    """Create model + config from checkpoint."""
+    config_dict = checkpoint["config"]
+
+    # Create experiment config with all required parameters
+    config = ExperimentConfig(
+        model=config_dict.get('model', 'ResNet-18'),
+        loss_function=config_dict.get('loss_function', 'CE'),
+        must_include=config_dict.get('must_include', True),
+        learning_rate=config_dict.get('learning_rate', 1e-3),
+        batch_size=config_dict.get('batch_size', 16),
+        weight_decay=config_dict.get('weight_decay', 1e-5),
+        optimizer=config_dict.get('optimizer', 'AdamW'),
+        scheduler=config_dict.get('scheduler', 'CosineAnnealing'),
+        image_augmentations=config_dict.get('image_augmentations', DEFAULT_AUGMENTATIONS.copy()),
+        dropout=config_dict.get('dropout', 0.1),
+        loss_specific_params=config_dict.get('loss_specific_params', 'class_weights=inverse_frequency'),
+        multi_target_strategy=config_dict.get('multi_target_strategy', 'Shared backbone + task-specific heads'),
+        single_target_strategy=config_dict.get('single_target_strategy', ''),
+        pretrained_weights=config_dict.get('pretrained_weights', 'ImageNet'),
+        fine_tuning_strategy=config_dict.get('fine_tuning_strategy', 'full'),
+        expected_gpu_memory=config_dict.get('expected_gpu_memory', '8-10GB'),
+        architectural_family=config_dict.get('architectural_family', 'CNN'),
+        class_weighting=config_dict.get('class_weighting', 'inverse_frequency'),
+        sampling_strategy=config_dict.get('sampling_strategy', 'balanced_batch'),
+        threshold_selection=config_dict.get('threshold_selection', 'F1_optimal')
+    )
+    single_target_strategy = config_dict.get('single_target_strategy', '')
+
+    print(f"Creating model: {config.model}")
+    print(f"Fine-tuning strategy: {config.fine_tuning_strategy}")
+    if single_target_strategy:
+        print(f"Single-target strategy: {single_target_strategy}")
+
+    # Align optional target feature dimension with saved task head input if present.
+    expected_head_dim = None
+    for key, tensor in checkpoint['model_state_dict'].items():
+        if '.task_heads.' in key and key.endswith('.weight'):
+            expected_head_dim = tensor.shape[1]
+            break
+
+    # Create model using ModelFactory
+    model = ModelFactory.create_model(
+        architecture=config.model,
+        num_classes=biomarker_config.total_output_size,
+        pretrained_weights=config.pretrained_weights,
+        fine_tuning_strategy=config.fine_tuning_strategy,
+        dropout=config.dropout,
+        biomarker_config=biomarker_config,
+        single_target_strategy=single_target_strategy,
+        single_target_output_dim=expected_head_dim
+    )
+
+    state_dict_to_load = checkpoint['model_state_dict']
+    if legacy_compat:
+        state_dict_to_load = _remap_legacy_state_dict_keys(state_dict_to_load)
+
+    _materialize_lazy_modules_from_state_dict(
+        model=model,
+        state_dict=state_dict_to_load,
+        dropout=config.dropout,
+    )
+
+    missing_keys, unexpected_keys = model.load_state_dict(state_dict_to_load, strict=False)
+    if missing_keys or unexpected_keys:
+        print("State dict loading warnings:")
+        if missing_keys:
+            print(f"  Missing keys: {missing_keys[:5]}{'...' if len(missing_keys) > 5 else ''}")
+        if unexpected_keys:
+            print(f"  Unexpected keys: {unexpected_keys[:5]}{'...' if len(unexpected_keys) > 5 else ''}")
+        print("Model loaded successfully despite key mismatches")
+    else:
+        print("Model state dict loaded perfectly!")
+
+    model.to(device)
+    model.eval()
+
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"Model loaded successfully!")
+    print(f"Total parameters: {total_params:,}")
+    print(f"Trainable parameters: {trainable_params:,}")
+    
+    return model, config
+
+def create_test_transforms(config: ExperimentConfig) -> transforms.Compose:
+    """Create test transforms that match training preprocessing exactly"""
+    
+    # CRITICAL: Parse augmentation string to get the EXACT same settings as training
+    from config.experiment_config import parse_augmentation_string
+    aug_params = parse_augmentation_string(config.image_augmentations)
+    
+    print(f"Test preprocessing settings:")
+    print(f"   Pretrained weights: {config.pretrained_weights}")
+    print(f"   ImageNet normalization: {aug_params['imagenet_norm']}")
+    print(f"   Image augmentations: {config.image_augmentations}")
+    
+    transform_list = [transforms.ToTensor()]
+    
+    # CRITICAL: Convert grayscale to 3-channel for pre-trained models (matches train.py)
+    transform_list.append(transforms.Lambda(lambda x: x.repeat(3, 1, 1)))
+    
+    # CRITICAL: Use the EXACT same normalization logic as train.py
+    # Only apply normalization if aug_params['imagenet_norm'] is True
+    if aug_params['imagenet_norm']:
+        if config.pretrained_weights == "ImageNet":
+            # Use ImageNet normalization for ImageNet pre-trained models
+            transform_list.append(transforms.Normalize(
+                mean=[0.485, 0.456, 0.406], 
+                std=[0.229, 0.224, 0.225]
+            ))
+        elif config.pretrained_weights == "RadImageNet":
+            # Use RadImageNet normalization (medical imaging specific)
+            transform_list.append(transforms.Normalize(
+                mean=[0.485, 0.456, 0.406],  # Using ImageNet stats as fallback
+                std=[0.229, 0.224, 0.225]   # RadImageNet likely uses similar normalization
+            ))
+        else:
+            # Use CT-specific normalization for non-pretrained models
+            transform_list.append(transforms.Normalize(
+                mean=[0.55001191, 0.55001191, 0.55001191], 
+                std=[0.18854326, 0.18854326, 0.18854326]
+            ))
+        print(f"Normalization applied: {config.pretrained_weights} normalization")
+    else:
+        print(f"No normalization applied (imagenet_norm=False)")
+    
+    return transforms.Compose(transform_list)
+
+def create_test_dataset(data_dir: str, biomarker_config: FlexibleBiomarkerConfig, 
+                       config: ExperimentConfig, size: int = 256, only_pred: bool = False, 
+                       test_csv: str = 'test.csv', batch_size: int = 16) -> DataLoader:
+    """Create test dataset and dataloader with matching preprocessing"""
+    
+    # Create transforms that match training exactly
+    transform = create_test_transforms(config)
+    
+    if only_pred:
+        # Test dataset without labels
+        test_dataset = PredictionDataset(data_dir, transforms=transform, size=size)
+        print(f"Created test dataset with {len(test_dataset)} images (prediction only)")
+    else:
+        # Use unified classifier dataset with explicit CSV selection
+        test_dataset = ClassifierDataset(
+            data_dir, 
+            biomarker_config, 
+            transforms=transform, 
+            size=size, 
+            train=False,
+            csv_file=test_csv
+        )
+        print(f"Created test dataset with {len(test_dataset)} samples")
+    
+    return DataLoader(
+        dataset=test_dataset, 
+        batch_size=batch_size, 
+        shuffle=False,
+        num_workers=4,
+        pin_memory=True
+    )
+
+def process_predictions(predictions: torch.Tensor, biomarker_config: FlexibleBiomarkerConfig) -> Dict[str, Any]:
+    """Process raw predictions into interpretable outputs"""
+    
+    results = {}
+    tensor_layout = biomarker_config.get_tensor_layout()
+    
+    # Process each biomarker type
+    for biomarker in biomarker_config.binary_biomarkers:
+        layout = tensor_layout[biomarker.name]
+        pred_slice = predictions[:, layout.start_idx:layout.end_idx]  # [B, 1]
+        
+        # Apply sigmoid for binary classification
+        prob = torch.sigmoid(pred_slice).cpu().numpy().flatten()
+        results[biomarker.name] = prob
+    
+    for biomarker in biomarker_config.multiclass_biomarkers:
+        layout = tensor_layout[biomarker.name]
+        pred_slice = predictions[:, layout.start_idx:layout.end_idx]  # [B, num_classes]
+        
+        # Apply softmax for multiclass classification
+        prob = F.softmax(pred_slice, dim=1).cpu().numpy()
+        pred_class = np.argmax(prob, axis=1)
+        
+        results[f"{biomarker.name}_probabilities"] = prob
+        results[f"{biomarker.name}_predicted_class"] = pred_class
+    
+    for biomarker in biomarker_config.continuous_biomarkers:
+        layout = tensor_layout[biomarker.name]
+        pred_slice = predictions[:, layout.start_idx:layout.end_idx]  # [B, 1]
+        
+        # Denormalize continuous predictions
+        raw_pred = pred_slice.cpu().numpy().flatten()
+        denormalized_pred = []
+        
+        for val in raw_pred:
+            denormalized_val = biomarker.denormalize(val)
+            denormalized_pred.append(denormalized_val)
+        
+        denormalized_pred = np.array(denormalized_pred)
+        
+        results[biomarker.name] = denormalized_pred
+    
+    return results
+
+def find_optimal_thresholds_on_validation(model: torch.nn.Module, biomarker_config: FlexibleBiomarkerConfig, 
+                                         data_dir: str, config: ExperimentConfig, size: int = 256, batch_size: int = 16) -> Dict[str, float]:
+    """Find optimal thresholds by running inference on validation set"""
+    
+    print("Finding optimal thresholds on validation set...")
+    
+    # Create validation dataset (use train=False to get val.csv)
+    transform = create_test_transforms(config)
+    val_dataset = ClassifierDataset(data_dir, biomarker_config, transforms=transform, size=size, train=False)
+    
+    val_dataloader = DataLoader(
+        dataset=val_dataset, 
+        batch_size=batch_size, 
+        shuffle=False,
+        num_workers=4,
+        pin_memory=True
+    )
+    
+    # Run inference on validation set
+    all_predictions = []
+    all_targets = []
+    
+    model.eval()
+    with torch.no_grad():
+        for batch_idx, (images, targets) in enumerate(tqdm(val_dataloader, desc="Validation inference")):
+            images = images.to(device)
+            targets = targets.to(device)
+            
+            # Convert single channel to 3-channel for models expecting RGB (matches train.py validation)
+            if images.shape[1] == 1:
+                images = images.repeat(1, 3, 1, 1)
+            
+            # Forward pass
+            predictions = model(images)
+            
+            all_predictions.append(predictions.detach().cpu())
+            all_targets.append(targets.detach().cpu())
+    
+    # Concatenate all predictions and targets
+    all_predictions = torch.cat(all_predictions, dim=0)
+    all_targets = torch.cat(all_targets, dim=0)
+    
+    # Find optimal thresholds
+    optimal_thresholds = {}
+    tensor_layout = biomarker_config.get_tensor_layout()
+    
+    # Get threshold search parameters from biomarker config (matches training exactly)
+    validation_config = biomarker_config.validation
+    threshold_range = validation_config.get('threshold_search_range', [0.1, 0.9])
+    threshold_steps = validation_config.get('threshold_search_steps', 9)
+    optimization_metric = validation_config.get('optimization_metric', 'f1_score')
+    fallback_threshold = validation_config.get('fallback_threshold', 0.5)
+    
+    print(f"Using threshold search: {threshold_steps} steps from {threshold_range[0]} to {threshold_range[1]}")
+    print(f"Optimizing for: {optimization_metric}")
+    
+    # Convert to numpy
+    predictions_np = all_predictions.numpy()
+    targets_np = all_targets.numpy()
+    
+    for biomarker in biomarker_config.binary_biomarkers:
+        layout = tensor_layout[biomarker.name]
+        
+        pred_logits = predictions_np[:, layout.start_idx]
+        pred_probs = 1 / (1 + np.exp(-pred_logits))  # Sigmoid
+        true_labels = targets_np[:, layout.start_idx].astype(int)
+        
+        # Skip if all labels are the same
+        if len(np.unique(true_labels)) < 2:
+            optimal_thresholds[biomarker.name] = fallback_threshold
+            print(f"  {biomarker.name}: Using fallback threshold ({fallback_threshold}) - insufficient label diversity")
+            continue
+        
+        # Find optimal threshold using the configured metric
+        best_threshold = fallback_threshold
+        best_score = 0.0
+        
+        # Use the EXACT same threshold search parameters as training
+        for threshold in np.linspace(threshold_range[0], threshold_range[1], threshold_steps):
+            pred_labels = (pred_probs > threshold).astype(int)
+            
+            # Calculate the optimization metric
+            tp = np.sum((pred_labels == 1) & (true_labels == 1))
+            fp = np.sum((pred_labels == 1) & (true_labels == 0))
+            fn = np.sum((pred_labels == 0) & (true_labels == 1))
+            tn = np.sum((pred_labels == 0) & (true_labels == 0))
+            
+            # Calculate metric based on configuration
+            if optimization_metric == 'f1_score' and tp + fp > 0 and tp + fn > 0:
+                precision = tp / (tp + fp)
+                recall = tp / (tp + fn)
+                score = 2 * (precision * recall) / (precision + recall)
+            elif optimization_metric == 'accuracy':
+                score = (tp + tn) / (tp + tn + fp + fn) if (tp + tn + fp + fn) > 0 else 0.0
+            elif optimization_metric == 'precision' and tp + fp > 0:
+                score = tp / (tp + fp)
+            elif optimization_metric == 'recall' and tp + fn > 0:
+                score = tp / (tp + fn)
+            elif optimization_metric == 'specificity' and tn + fp > 0:
+                score = tn / (tn + fp)
+            else:
+                score = 0.0  # Fallback
+            
+            if score > best_score:
+                best_score = score
+                best_threshold = threshold
+        
+        optimal_thresholds[biomarker.name] = best_threshold
+        print(f"  {biomarker.name}: threshold={best_threshold:.3f}, {optimization_metric}={best_score:.3f}")
+    
+    return optimal_thresholds
+
+def bootstrap_metric_ci(y_true, y_pred, metric_fn, n_bootstraps=1000, ci=0.95, seed=42):
+    """Calculate bootstrapped confidence intervals for a metric"""
+    rng = np.random.RandomState(seed)
+    scores = []
+    
+    for _ in range(n_bootstraps):
+        indices = rng.randint(0, len(y_pred), len(y_pred))
+        if len(np.unique(y_true[indices])) < 2:
+            continue
+        try:
+            score = metric_fn(y_true[indices], y_pred[indices])
+            if not np.isnan(score):
+                scores.append(score)
+        except (ValueError, ZeroDivisionError):
+            continue
+    
+    if len(scores) < 10:  # Need minimum samples for reliable CI
+        return np.nan, np.nan
+    
+    sorted_scores = np.sort(scores)
+    lower = np.percentile(sorted_scores, ((1.0 - ci) / 2.0) * 100)
+    upper = np.percentile(sorted_scores, (1 - (1.0 - ci) / 2.0) * 100)
+    return lower, upper
+
+def calculate_enhanced_metrics(predictions: torch.Tensor, targets: torch.Tensor, 
+                             biomarker_config: FlexibleBiomarkerConfig, 
+                             optimal_thresholds: Dict[str, float] = None) -> Dict[str, Any]:
+    """Calculate enhanced metrics with bootstrapped confidence intervals"""
+    
+    # Convert to numpy
+    if isinstance(predictions, torch.Tensor):
+        predictions = predictions.detach().cpu().numpy()
+    if isinstance(targets, torch.Tensor):
+        targets = targets.detach().cpu().numpy()
+    
+    all_metrics = {}
+    tensor_layout = biomarker_config.get_tensor_layout()
+    
+    # Binary classification metrics
+    for biomarker in biomarker_config.binary_biomarkers:
+        layout = tensor_layout[biomarker.name]
+        
+        pred_logits = predictions[:, layout.start_idx]
+        pred_probs = 1 / (1 + np.exp(-pred_logits))  # Sigmoid
+        true_labels = targets[:, layout.start_idx].astype(int)
+        
+        # Skip if all labels are the same
+        if len(np.unique(true_labels)) < 2:
+            continue
+        
+        # Get optimal threshold
+        threshold = optimal_thresholds.get(biomarker.name, 0.5) if optimal_thresholds else 0.5
+        pred_labels = (pred_probs > threshold).astype(int)
+        
+        # Calculate metrics
+        metrics = {}
+        
+        # AUROC (threshold-independent)
+        try:
+            auroc = roc_auc_score(true_labels, pred_probs)
+            auroc_ci = bootstrap_metric_ci(true_labels, pred_probs, roc_auc_score)
+            metrics['auroc'] = auroc
+            metrics['auroc_ci'] = auroc_ci
+        except (ValueError, ZeroDivisionError):
+            metrics['auroc'] = np.nan
+            metrics['auroc_ci'] = (np.nan, np.nan)
+        
+        # Confusion matrix components
+        tp = np.sum((pred_labels == 1) & (true_labels == 1))
+        tn = np.sum((pred_labels == 0) & (true_labels == 0))
+        fp = np.sum((pred_labels == 1) & (true_labels == 0))
+        fn = np.sum((pred_labels == 0) & (true_labels == 1))
+        
+        # Precision, Recall, Specificity, F1
+        precision = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+        recall = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        specificity = tn / (tn + fp) if (tn + fp) > 0 else 0.0
+        f1 = 2 * (precision * recall) / (precision + recall) if (precision + recall) > 0 else 0.0
+        accuracy = (tp + tn) / (tp + tn + fp + fn)
+        
+        # Calculate confidence intervals for threshold-dependent metrics
+        def precision_fn(y_true, y_pred):
+            pred_binary = (y_pred > threshold).astype(int)
+            tp = np.sum((pred_binary == 1) & (y_true == 1))
+            fp = np.sum((pred_binary == 1) & (y_true == 0))
+            return tp / (tp + fp) if (tp + fp) > 0 else 0.0
+        
+        def recall_fn(y_true, y_pred):
+            pred_binary = (y_pred > threshold).astype(int)
+            tp = np.sum((pred_binary == 1) & (y_true == 1))
+            fn = np.sum((pred_binary == 0) & (y_true == 1))
+            return tp / (tp + fn) if (tp + fn) > 0 else 0.0
+        
+        def specificity_fn(y_true, y_pred):
+            pred_binary = (y_pred > threshold).astype(int)
+            tn = np.sum((pred_binary == 0) & (y_true == 0))
+            fp = np.sum((pred_binary == 1) & (y_true == 0))
+            return tn / (tn + fp) if (tn + fp) > 0 else 0.0
+        
+        def f1_fn(y_true, y_pred):
+            pred_binary = (y_pred > threshold).astype(int)
+            tp = np.sum((pred_binary == 1) & (y_true == 1))
+            fp = np.sum((pred_binary == 1) & (y_true == 0))
+            fn = np.sum((pred_binary == 0) & (y_true == 1))
+            prec = tp / (tp + fp) if (tp + fp) > 0 else 0.0
+            rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0
+            return 2 * (prec * rec) / (prec + rec) if (prec + rec) > 0 else 0.0
+        
+        def accuracy_fn(y_true, y_pred):
+            pred_binary = (y_pred > threshold).astype(int)
+            return (pred_binary == y_true).mean()
+        
+        # Calculate confidence intervals
+        precision_ci = bootstrap_metric_ci(true_labels, pred_probs, precision_fn)
+        recall_ci = bootstrap_metric_ci(true_labels, pred_probs, recall_fn)
+        specificity_ci = bootstrap_metric_ci(true_labels, pred_probs, specificity_fn)
+        f1_ci = bootstrap_metric_ci(true_labels, pred_probs, f1_fn)
+        accuracy_ci = bootstrap_metric_ci(true_labels, pred_probs, accuracy_fn)
+        
+        # Store metrics
+        metrics.update({
+            'precision': precision,
+            'precision_ci': precision_ci,
+            'recall': recall,
+            'recall_ci': recall_ci,
+            'specificity': specificity,
+            'specificity_ci': specificity_ci,
+            'f1_score': f1,
+            'f1_score_ci': f1_ci,
+            'accuracy': accuracy,
+            'accuracy_ci': accuracy_ci,
+            'threshold_used': threshold
+        })
+        
+        all_metrics[biomarker.name] = metrics
+    
+    # Regression metrics
+    for biomarker in biomarker_config.continuous_biomarkers:
+        layout = tensor_layout[biomarker.name]
+        
+        pred_values_raw = predictions[:, layout.start_idx]
+        true_values_raw = targets[:, layout.start_idx]
+        
+        # CRITICAL FIX: Do NOT apply sigmoid to regression predictions!
+        # Regression models output raw continuous values, not probabilities
+        # The model was trained without sigmoid activation for continuous outputs
+        
+        # Denormalize predictions and targets for proper metric calculation
+        pred_values_denorm = np.array([biomarker.denormalize(val) for val in pred_values_raw])
+        true_values_denorm = np.array([biomarker.denormalize(val) for val in true_values_raw])
+        
+        
+        # Calculate metrics on denormalized values
+        mae = mean_absolute_error(true_values_denorm, pred_values_denorm)
+        mse = mean_squared_error(true_values_denorm, pred_values_denorm)
+        r2 = r2_score(true_values_denorm, pred_values_denorm)
+        
+        # Calculate confidence intervals on denormalized values
+        def mae_fn(y_true, y_pred):
+            return mean_absolute_error(y_true, y_pred)
+        
+        def mse_fn(y_true, y_pred):
+            return mean_squared_error(y_true, y_pred)
+        
+        def r2_fn(y_true, y_pred):
+            return r2_score(y_true, y_pred)
+        
+        mae_ci = bootstrap_metric_ci(true_values_denorm, pred_values_denorm, mae_fn)
+        mse_ci = bootstrap_metric_ci(true_values_denorm, pred_values_denorm, mse_fn)
+        r2_ci = bootstrap_metric_ci(true_values_denorm, pred_values_denorm, r2_fn)
+        
+        all_metrics[biomarker.name] = {
+            'mae': mae,
+            'mae_ci': mae_ci,
+            'mse': mse,
+            'mse_ci': mse_ci,
+            'r2_score': r2,
+            'r2_score_ci': r2_ci
+        }
+    
+    return all_metrics
+
+def run_inference(model: torch.nn.Module, test_dataloader: DataLoader, 
+                 biomarker_config: FlexibleBiomarkerConfig, optimal_thresholds: Dict[str, float] = None,
+                 only_pred: bool = False) -> Dict[str, Any]:
+    """Run inference on test set"""
+    
+    all_results = {}
+    all_targets = {}
+    all_predictions = []
+    study_ids = []
+    
+    print("Running inference...")
+    
+    with torch.no_grad():
+        for batch_idx, batch_data in enumerate(tqdm(test_dataloader)):
+            if only_pred:
+                images = batch_data
+                batch_study_ids = [test_dataloader.dataset.at(batch_idx * args.batch_size + i) 
+                                 for i in range(len(images))]
+            else:
+                images, targets = batch_data
+                targets = targets.to(device)
+                batch_study_ids = [test_dataloader.dataset.at(batch_idx * args.batch_size + i) 
+                                 for i in range(len(images))]
+                
+                # Store targets for metrics calculation
+                for i, target in enumerate(targets):
+                    study_id = batch_study_ids[i]
+                    all_targets[study_id] = target.cpu().numpy()
+            
+            images = images.to(device)
+            
+            # Convert single channel to 3-channel for models expecting RGB (matches train.py validation)
+            if images.shape[1] == 1:
+                images = images.repeat(1, 3, 1, 1)
+            
+            # Forward pass
+            predictions = model(images)
+            all_predictions.append(predictions.cpu())
+            study_ids.extend(batch_study_ids)
+    
+    # Concatenate all predictions
+    all_predictions = torch.cat(all_predictions, dim=0)
+    
+    # Process predictions
+    processed_results = process_predictions(all_predictions, biomarker_config)
+    
+    # Add study IDs
+    processed_results['STUDY_ID'] = study_ids
+    
+    # Calculate metrics if ground truth available
+    if not only_pred and all_targets:
+        print("Calculating metrics...")
+        
+        # Convert targets to tensor format - CRITICAL: ensure predictions and targets are aligned
+        target_tensors = []
+        prediction_indices = []
+        for idx, study_id in enumerate(study_ids):
+            if study_id in all_targets:
+                target_tensors.append(torch.from_numpy(all_targets[study_id]))
+                prediction_indices.append(idx)
+        
+        if target_tensors:
+            target_tensor = torch.stack(target_tensors).to(device)
+            # Only use predictions that have corresponding targets
+            aligned_predictions = all_predictions[prediction_indices].to(device)
+            metrics = calculate_enhanced_metrics(aligned_predictions, target_tensor, biomarker_config, optimal_thresholds)
+            processed_results['metrics'] = metrics
+    
+    return processed_results
+
+def save_results(results: Dict[str, Any], output_dir: str, biomarker_config: FlexibleBiomarkerConfig):
+    """Save results to files"""
+    
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Save predictions CSV
+    if args.save_predictions:
+        # Create DataFrame from results
+        df_data = {}
+        
+        # Add study IDs
+        df_data['STUDY_ID'] = results['STUDY_ID']
+        
+        # Add predictions for each biomarker
+        for biomarker in biomarker_config.binary_biomarkers:
+            df_data[biomarker.name] = results[biomarker.name]
+        
+        for biomarker in biomarker_config.multiclass_biomarkers:
+            df_data[f"{biomarker.name}_predicted_class"] = results[f"{biomarker.name}_predicted_class"]
+            # Save probabilities as separate columns
+            probs = results[f"{biomarker.name}_probabilities"]
+            for i, class_name in enumerate(biomarker.classes):
+                df_data[f"{biomarker.name}_{class_name}_prob"] = probs[:, i]
+        
+        for biomarker in biomarker_config.continuous_biomarkers:
+            df_data[biomarker.name] = results[biomarker.name]
+        
+        df = pd.DataFrame(df_data)
+        predictions_path = os.path.join(output_dir, 'predictions.csv')
+        df.to_csv(predictions_path, index=False)
+        print(f"Predictions saved to: {predictions_path}")
+    
+    # Save metrics (only if --save_metrics flag is used)
+    if 'metrics' in results and args.save_metrics:
+        metrics = results['metrics']
+        
+        # Save detailed metrics JSON
+        metrics_path = os.path.join(output_dir, 'test_metrics.json')
+        with open(metrics_path, 'w') as f:
+            json.dump(metrics, f, indent=2)
+        print(f"Detailed metrics saved to: {metrics_path}")
+    
+    # Print summary metrics (always show, regardless of save_metrics flag)
+    if 'metrics' in results:
+        metrics = results['metrics']
+        print("\n" + "="*60)
+        print("TEST RESULTS SUMMARY")
+        print("="*60)
+        
+        # Binary classification metrics
+        if biomarker_config.binary_biomarkers:
+            print("\nBinary Classification Metrics (with 95% CI):")
+            for biomarker in biomarker_config.binary_biomarkers:
+                if biomarker.name in metrics:
+                    metric_data = metrics[biomarker.name]
+                    print(f"  {biomarker.name}:")
+                    
+                    # AUROC
+                    auroc = metric_data.get('auroc', np.nan)
+                    auroc_ci = metric_data.get('auroc_ci', (np.nan, np.nan))
+                    if not np.isnan(auroc):
+                        print(f"    AUROC: {auroc:.4f} [{auroc_ci[0]:.4f}, {auroc_ci[1]:.4f}]")
+                    
+                    # Precision
+                    precision = metric_data.get('precision', np.nan)
+                    precision_ci = metric_data.get('precision_ci', (np.nan, np.nan))
+                    if not np.isnan(precision):
+                        print(f"    Precision: {precision:.4f} [{precision_ci[0]:.4f}, {precision_ci[1]:.4f}]")
+                    
+                    # Recall
+                    recall = metric_data.get('recall', np.nan)
+                    recall_ci = metric_data.get('recall_ci', (np.nan, np.nan))
+                    if not np.isnan(recall):
+                        print(f"    Recall: {recall:.4f} [{recall_ci[0]:.4f}, {recall_ci[1]:.4f}]")
+                    
+                    # Specificity
+                    specificity = metric_data.get('specificity', np.nan)
+                    specificity_ci = metric_data.get('specificity_ci', (np.nan, np.nan))
+                    if not np.isnan(specificity):
+                        print(f"    Specificity: {specificity:.4f} [{specificity_ci[0]:.4f}, {specificity_ci[1]:.4f}]")
+                    
+                    # F1-Score
+                    f1 = metric_data.get('f1_score', np.nan)
+                    f1_ci = metric_data.get('f1_score_ci', (np.nan, np.nan))
+                    if not np.isnan(f1):
+                        print(f"    F1-Score: {f1:.4f} [{f1_ci[0]:.4f}, {f1_ci[1]:.4f}]")
+                    
+                    # Accuracy
+                    accuracy = metric_data.get('accuracy', np.nan)
+                    accuracy_ci = metric_data.get('accuracy_ci', (np.nan, np.nan))
+                    if not np.isnan(accuracy):
+                        print(f"    Accuracy: {accuracy:.4f} [{accuracy_ci[0]:.4f}, {accuracy_ci[1]:.4f}]")
+                    
+                    # Threshold used
+                    threshold = metric_data.get('threshold_used', 'N/A')
+                    print(f"    Threshold used: {threshold}")
+        
+        # Multiclass classification metrics
+        if biomarker_config.multiclass_biomarkers:
+            print("\nMulticlass Classification Metrics:")
+            for biomarker in biomarker_config.multiclass_biomarkers:
+                if biomarker.name in metrics:
+                    metric_data = metrics[biomarker.name]
+                    print(f"  {biomarker.name}:")
+                    print(f"    Accuracy: {metric_data.get('accuracy', 'N/A'):.4f}")
+                    print(f"    F1-Score (macro): {metric_data.get('f1_score_macro', 'N/A'):.4f}")
+        
+        # Regression metrics
+        if biomarker_config.continuous_biomarkers:
+            print("\nRegression Metrics (with 95% CI):")
+            for biomarker in biomarker_config.continuous_biomarkers:
+                if biomarker.name in metrics:
+                    metric_data = metrics[biomarker.name]
+                    print(f"  {biomarker.name}:")
+                    
+                    # MAE
+                    mae = metric_data.get('mae', np.nan)
+                    mae_ci = metric_data.get('mae_ci', (np.nan, np.nan))
+                    if not np.isnan(mae):
+                        print(f"    MAE: {mae:.4f} [{mae_ci[0]:.4f}, {mae_ci[1]:.4f}]")
+                    
+                    # MSE
+                    mse = metric_data.get('mse', np.nan)
+                    mse_ci = metric_data.get('mse_ci', (np.nan, np.nan))
+                    if not np.isnan(mse):
+                        print(f"    MSE: {mse:.4f} [{mse_ci[0]:.4f}, {mse_ci[1]:.4f}]")
+                    
+                    # R²
+                    r2 = metric_data.get('r2_score', np.nan)
+                    r2_ci = metric_data.get('r2_score_ci', (np.nan, np.nan))
+                    if not np.isnan(r2):
+                        print(f"    R²: {r2:.4f} [{r2_ci[0]:.4f}, {r2_ci[1]:.4f}]")
+        
+        # Overall metrics
+        if 'average_auroc' in metrics and metrics['average_auroc'] > 0:
+            print(f"\nOverall Classification Performance:")
+            print(f"  Average AUROC: {metrics['average_auroc']:.4f}")
+            print(f"  Median AUROC: {metrics['median_auroc']:.4f}")
+        
+        if 'avg_regression_loss' in metrics:
+            print(f"\nOverall Regression Performance:")
+            print(f"  Average Regression Loss: {metrics['avg_regression_loss']:.4f}")
+        
+        print("="*60)
+
+def main():
+    global args
+    args = arg_parse()
+    
+    print("="*60)
+    print("FLEXIBLE MULTI-TASK TESTING")
+    print("="*60)
+    
+    # Load biomarker configuration
+    print(f"Loading biomarker configuration from: {args.biomarker_config}")
+    biomarker_config = FlexibleBiomarkerConfig(args.biomarker_config)
+    biomarker_config.print_summary()
+    
+    # Load checkpoint
+    checkpoint = load_checkpoint(args.checkpoint_path, legacy_compat=args.legacy_checkpoint_compat)
+    
+    # Create model and get config
+    model, config = create_model_from_checkpoint(
+        checkpoint,
+        biomarker_config,
+        legacy_compat=args.legacy_checkpoint_compat
+    )
+    
+    # Load optimal thresholds from checkpoint or find them on validation set
+    optimal_thresholds = checkpoint.get('optimal_thresholds', {})
+    if optimal_thresholds:
+        print(f"Loaded optimal thresholds from checkpoint: {optimal_thresholds}")
+    else:
+        print("No optimal thresholds found in checkpoint.")
+        if biomarker_config.binary_biomarkers:
+            print("Finding optimal thresholds on validation set...")
+            # Use validation data directory if specified, otherwise use same as test data
+            val_data_dir = args.val_data_dir if args.val_data_dir else args.data_dir
+            optimal_thresholds = find_optimal_thresholds_on_validation(
+                model, biomarker_config, val_data_dir, config, args.size, args.batch_size
+            )
+        else:
+            print("No binary biomarkers - skipping threshold optimization")
+            optimal_thresholds = {}
+    
+    # Create test dataset with matching preprocessing
+    test_dataloader = create_test_dataset(
+        args.data_dir, 
+        biomarker_config, 
+        config,
+        args.size, 
+        args.only_pred,
+        args.test_csv,
+        args.batch_size
+    )
+    
+    # Run inference
+    results = run_inference(model, test_dataloader, biomarker_config, optimal_thresholds, args.only_pred)
+    
+    # Save results
+    save_results(results, args.output_dir, biomarker_config)
+    
+    print(f"\nTesting completed! Results saved to: {args.output_dir}")
+
+if __name__ == "__main__":
+    main()

code/train.py

@@ -0,0 +1,923 @@
+"""
+Flexible Training Pipeline for Multi-Task Comorbidity Detection
+Uses the flexible biomarker configuration system for any task structure
+"""
+
+import os
+import random
+import numpy as np
+import torch
+import torch.optim as optim
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, WeightedRandomSampler
+from torch.utils.tensorboard import SummaryWriter
+from torchvision import transforms
+from sklearn.utils.class_weight import compute_class_weight
+from tqdm import tqdm
+import json
+import time
+import logging
+import sys
+from argparse import ArgumentParser
+from typing import Dict, List, Tuple, Any
+
+# Import our custom modules
+from dataset import ClassifierDataset
+from model.model_factory import ModelFactory
+from model.flexible_multitask_head import FlexibleMultiTaskLoss, FlexibleMetricsCalculator
+from model.gradnorm_loss import GradNormLoss, GradNormTrainer
+from config.biomarker_config import FlexibleBiomarkerConfig
+from config.experiment_config import (
+    ExperimentConfig, get_model_defaults, DEFAULT_AUGMENTATIONS,
+    parse_augmentation_string, create_optimizer, create_scheduler
+)
+from utils.checkpoints import save_checkpoint, load_checkpoint
+
+# Set device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Using device: {device}")
+
+
+def set_global_seed(seed: int, deterministic: bool = False) -> None:
+    """Set global random seeds for reproducible training runs."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+    if deterministic:
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+    else:
+        torch.backends.cudnn.deterministic = False
+        torch.backends.cudnn.benchmark = True
+
+
+def normalize_fine_tuning_strategy(strategy: str) -> str:
+    """Normalize fine-tuning strategy values to canonical internal names."""
+    normalized = strategy.strip().lower().replace("-", "_").replace(" ", "_")
+    if normalized in {"linear_probe", "linearprobe"}:
+        return "linear_probe"
+    return "full"
+
+
+def compute_class_weights_for_dataset(dataset, biomarker_config: FlexibleBiomarkerConfig):
+    """Compute class weights for balanced training"""
+    class_weights = {}
+    
+    # Get all target tensors
+    all_targets = dataset.targets
+    
+    # Compute weights for binary tasks
+    for biomarker in biomarker_config.binary_biomarkers:
+        layout = biomarker_config.get_tensor_layout()[biomarker.name]
+        labels = all_targets[:, layout.start_idx]
+        
+        unique_classes = np.unique(labels)
+        if len(unique_classes) > 1:
+            weights = compute_class_weight('balanced', classes=unique_classes, y=labels)
+            # Use positive class weight for BCE
+            pos_weight = weights[1] / weights[0] if len(weights) > 1 else 1.0
+            class_weights[biomarker.name] = pos_weight
+        else:
+            class_weights[biomarker.name] = 1.0
+    
+    return class_weights
+
+
+def create_data_transforms(config: ExperimentConfig, is_training=True):
+    """Create data transforms optimized for different pre-trained models on medical images"""
+    aug_params = parse_augmentation_string(config.image_augmentations)
+    
+    if is_training:
+        transform_list = []
+        
+        # Different augmentation strategies based on pre-training source
+        if config.pretrained_weights == "RadImageNet":
+            # RadImageNet-specific augmentations (more conservative for medical domain)
+            if aug_params['horizontal_flip']:
+                # Very conservative for medical images
+                transform_list.append(transforms.RandomHorizontalFlip(p=0.2))
+            
+            # Use RandomApply to prevent over-augmentation
+            geometric_augs = []
+            
+            if aug_params['rotation'] > 0:
+                # Very conservative rotation for medical images
+                geometric_augs.append(transforms.RandomRotation(degrees=aug_params['rotation']//3))  # 1/3 the rotation
+            
+            if aug_params['random_crop']:
+                # Minimal cropping to preserve anatomical features
+                geometric_augs.append(transforms.RandomResizedCrop(
+                    256, 
+                    scale=(0.95, 1.0),     # Very conservative cropping
+                    ratio=(0.9, 1.1)       # Minimal aspect ratio change
+                ))
+            
+            # Apply geometric augmentations with low probability
+            if geometric_augs:
+                transform_list.append(transforms.RandomApply(geometric_augs, p=0.4))
+            
+            # Minimal color augmentations for medical images
+            if aug_params['color_jitter']:
+                transform_list.append(transforms.RandomApply([
+                    transforms.ColorJitter(
+                        brightness=aug_params['brightness'] * 0.3,  # Very reduced intensity
+                        contrast=aug_params['contrast'] * 0.3       # Very reduced intensity
+                    )
+                ], p=0.3))  # Very low probability
+            
+        else:
+            # ImageNet or non-pretrained augmentations (more aggressive)
+            if aug_params['horizontal_flip']:
+                # Reduced probability for medical images (anatomical consistency)
+                transform_list.append(transforms.RandomHorizontalFlip(p=0.3))
+            
+            # Use RandomApply to prevent over-augmentation
+            geometric_augs = []
+            
+            if aug_params['rotation'] > 0:
+                # More conservative rotation for medical images
+                geometric_augs.append(transforms.RandomRotation(degrees=aug_params['rotation']//2))  # Half the rotation
+            
+            if aug_params['random_crop']:
+                # Less aggressive cropping to preserve anatomical features
+                geometric_augs.append(transforms.RandomResizedCrop(
+                    256, 
+                    scale=(0.9, 1.0),      # Less aggressive cropping
+                    ratio=(0.8, 1.2)       # Slightly wider aspect ratio
+                ))
+            
+            # Apply geometric augmentations with moderate probability
+            if geometric_augs:
+                transform_list.append(transforms.RandomApply(geometric_augs, p=0.6))
+            
+            # Color augmentations (less critical for grayscale, but helps with domain adaptation)
+            if aug_params['color_jitter']:
+                transform_list.append(transforms.RandomApply([
+                    transforms.ColorJitter(
+                        brightness=aug_params['brightness'] * 0.5,  # Reduced intensity
+                        contrast=aug_params['contrast'] * 0.5       # Reduced intensity
+                    )
+                ], p=0.4))  # Lower probability
+        
+        # Convert to tensor
+        transform_list.append(transforms.ToTensor())
+        
+        # CRITICAL: Convert grayscale to 3-channel for pre-trained models
+        transform_list.append(transforms.Lambda(lambda x: x.repeat(3, 1, 1)))
+        
+        # Add normalization - use appropriate stats based on pre-training
+        if aug_params['imagenet_norm']:
+            if config.pretrained_weights == "ImageNet":
+                # Use ImageNet normalization for ImageNet pre-trained models
+                transform_list.append(transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406], 
+                    std=[0.229, 0.224, 0.225]
+                ))
+            elif config.pretrained_weights == "RadImageNet":
+                # Use RadImageNet normalization (medical imaging specific)
+                # Note: These are estimated values - you may need to adjust based on actual RadImageNet stats
+                transform_list.append(transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406],  # Using ImageNet stats as fallback
+                    std=[0.229, 0.224, 0.225]   # RadImageNet likely uses similar normalization
+                ))
+            else:
+                # Use CT-specific normalization for non-pretrained models
+                transform_list.append(transforms.Normalize(
+                    mean=[0.55001191, 0.55001191, 0.55001191], 
+                    std=[0.18854326, 0.18854326, 0.18854326]
+                ))
+        
+        return transforms.Compose(transform_list)
+    
+    else:
+        # Validation/test transforms (no augmentation)
+        transform_list = [transforms.ToTensor()]
+        
+        # CRITICAL: Convert grayscale to 3-channel for pre-trained models
+        transform_list.append(transforms.Lambda(lambda x: x.repeat(3, 1, 1)))
+        
+        if aug_params['imagenet_norm']:
+            if config.pretrained_weights == "ImageNet":
+                # Use ImageNet normalization for ImageNet pre-trained models
+                transform_list.append(transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406], 
+                    std=[0.229, 0.224, 0.225]
+                ))
+            elif config.pretrained_weights == "RadImageNet":
+                # Use RadImageNet normalization (medical imaging specific)
+                # Note: These are estimated values - you may need to adjust based on actual RadImageNet stats
+                transform_list.append(transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406],  # Using ImageNet stats as fallback
+                    std=[0.229, 0.224, 0.225]   # RadImageNet likely uses similar normalization
+                ))
+            else:
+                # Use CT-specific normalization for non-pretrained models
+                transform_list.append(transforms.Normalize(
+                    mean=[0.55001191, 0.55001191, 0.55001191], 
+                    std=[0.18854326, 0.18854326, 0.18854326]
+                ))
+        
+        return transforms.Compose(transform_list)
+
+
+def setup_logging(output_dir: str, experiment_name: str):
+    """Set up comprehensive logging for the experiment"""
+    # Create logs directory
+    logs_dir = os.path.join(output_dir, 'logs')
+    os.makedirs(logs_dir, exist_ok=True)
+    
+    # Set up main logger
+    logger = logging.getLogger('experiment')
+    logger.setLevel(logging.INFO)
+    
+    # Clear existing handlers
+    logger.handlers.clear()
+    
+    # Create formatters
+    detailed_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    simple_formatter = logging.Formatter('%(asctime)s - %(message)s')
+    
+    # File handler for detailed logs
+    detailed_log_file = os.path.join(logs_dir, 'experiment_detailed.log')
+    file_handler = logging.FileHandler(detailed_log_file)
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(detailed_formatter)
+    logger.addHandler(file_handler)
+    
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+    console_handler.setFormatter(simple_formatter)
+    logger.addHandler(console_handler)
+    
+    # Create separate logger for training progress
+    training_logger = logging.getLogger('training')
+    training_logger.setLevel(logging.INFO)
+    training_logger.handlers.clear()
+    
+    training_log_file = os.path.join(logs_dir, 'training_progress.log')
+    training_handler = logging.FileHandler(training_log_file)
+    training_handler.setLevel(logging.INFO)
+    training_handler.setFormatter(simple_formatter)
+    training_logger.addHandler(training_handler)
+    training_logger.addHandler(console_handler)
+    
+    # Log experiment start
+    logger.info(f"Starting experiment: {experiment_name}")
+    logger.info(f"Output directory: {output_dir}")
+    logger.info(f"Logs directory: {logs_dir}")
+    
+    return logger, training_logger
+
+
+def create_balanced_sampler(dataset, biomarker_config: FlexibleBiomarkerConfig):
+    """Create balanced sampler for training"""
+    # Get all target tensors
+    all_targets = dataset.targets
+    
+    # Create sample weights based on inverse frequency
+    sample_weights = np.ones(len(dataset), dtype=np.float64)
+    
+    # Weight based on binary biomarkers
+    for biomarker in biomarker_config.binary_biomarkers:
+        layout = biomarker_config.get_tensor_layout()[biomarker.name]
+        labels = all_targets[:, layout.start_idx]
+        
+        unique, counts = np.unique(labels, return_counts=True)
+        class_weights = len(labels) / (len(unique) * counts)
+        
+        for j, label in enumerate(labels):
+            sample_weights[j] *= class_weights[int(label)]
+    
+    # Convert to torch.DoubleTensor to prevent overflow and match WeightedRandomSampler expectations
+    sample_weights_tensor = torch.from_numpy(sample_weights).double()
+    
+    return WeightedRandomSampler(sample_weights_tensor, len(sample_weights_tensor), replacement=True)
+
+
+def train_epoch(model, dataloader, criterion, optimizer, device, metrics_calc, gradnorm_trainer=None):
+    """Train for one epoch"""
+    model.train()
+    
+    total_loss = 0
+    all_predictions = []
+    all_targets = []
+    loss_components = {'total_loss': 0}
+    
+    for batch_idx, (images, targets) in enumerate(tqdm(dataloader, desc="Training")):
+        images = images.to(device)
+        targets = targets.to(device)
+        
+        # Convert single channel to 3-channel for models expecting RGB
+        if images.shape[1] == 1:
+            images = images.repeat(1, 3, 1, 1)
+        
+        # Forward pass
+        predictions = model(images)
+        
+        # Calculate loss - use GradNorm if available
+        if gradnorm_trainer is not None:
+            loss, loss_dict = gradnorm_trainer.compute_loss(model, predictions, targets)
+        else:
+            loss, loss_dict = criterion(predictions, targets)
+        
+        # Backward pass
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+
+        # Accumulate metrics
+        total_loss += loss.item()
+        for key, value in loss_dict.items():
+            if key not in loss_components:
+                loss_components[key] = 0
+            loss_components[key] += value
+        
+        # Store predictions and targets for metric calculation
+        all_predictions.append(predictions.detach().cpu())
+        all_targets.append(targets.detach().cpu())
+    
+    # Calculate metrics
+    all_predictions = torch.cat(all_predictions, dim=0)
+    all_targets = torch.cat(all_targets, dim=0)
+    
+    metrics = metrics_calc.calculate_all_metrics(all_predictions, all_targets)
+    
+    # Average losses
+    avg_loss = total_loss / len(dataloader)
+    for key in loss_components:
+        loss_components[key] /= len(dataloader)
+    
+    return avg_loss, metrics, loss_components
+
+
+def validate_epoch(model, dataloader, criterion, device, metrics_calc):
+    """Validate for one epoch"""
+    model.eval()
+    
+    total_loss = 0
+    all_predictions = []
+    all_targets = []
+    loss_components = {'total_loss': 0}
+    
+    with torch.no_grad():
+        for batch_idx, (images, targets) in enumerate(tqdm(dataloader, desc="Validation")):
+            images = images.to(device)
+            targets = targets.to(device)
+            
+            # Convert single channel to 3-channel for models expecting RGB
+            if images.shape[1] == 1:
+                images = images.repeat(1, 3, 1, 1)
+            
+            # Forward pass
+            predictions = model(images)
+            
+            # Calculate loss
+            loss, loss_dict = criterion(predictions, targets)
+            
+            # Accumulate metrics
+            total_loss += loss.item()
+            for key, value in loss_dict.items():
+                if key not in loss_components:
+                    loss_components[key] = 0
+                loss_components[key] += value
+            
+            # Store predictions and targets for metric calculation
+            all_predictions.append(predictions.detach().cpu())
+            all_targets.append(targets.detach().cpu())
+    
+    # Calculate metrics with threshold optimization
+    all_predictions = torch.cat(all_predictions, dim=0)
+    all_targets = torch.cat(all_targets, dim=0)
+    
+    # Update optimal thresholds based on validation data
+    metrics_calc.update_optimal_thresholds(all_predictions, all_targets)
+    
+    # Calculate metrics using optimal thresholds
+    metrics = metrics_calc.calculate_all_metrics(all_predictions, all_targets)
+    
+    # Average losses
+    avg_loss = total_loss / len(dataloader)
+    for key in loss_components:
+        loss_components[key] /= len(dataloader)
+    
+    return avg_loss, metrics, loss_components
+
+
+def train_model(
+    config: ExperimentConfig,
+    data_dir: str,
+    output_dir: str,
+    biomarker_config: FlexibleBiomarkerConfig,
+    epochs: int = 100,
+    seed: int = 42,
+):
+    """Main training function"""
+    
+    # Safety check: if directory exists and has important files, create a new one
+    if os.path.exists(output_dir):
+        important_files = ['best_checkpoint.pth', 'config.json', 'experiment_results.csv']
+        has_important_files = any(os.path.exists(os.path.join(output_dir, f)) for f in important_files)
+        
+        if has_important_files:
+            import datetime
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+            original_output_dir = output_dir
+            output_dir = f"{output_dir}_{timestamp}"
+            print(f"Warning: Output directory {original_output_dir} exists with important files.")
+            print(f"Using new directory: {output_dir}")
+    
+    # Create output directory
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Setup comprehensive logging
+    logger, training_logger = setup_logging(output_dir, config.experiment_name)
+    
+    # Setup tensorboard logging
+    writer = SummaryWriter(log_dir=os.path.join(output_dir, 'tensorboard'))
+    
+    # Save configuration
+    config_file = os.path.join(output_dir, 'config.json')
+    with open(config_file, 'w') as f:
+        json.dump(config.to_dict(), f, indent=2)
+    logger.info(f"Configuration saved to: {config_file}")
+    
+    # Save biomarker configuration
+    biomarker_config_file = os.path.join(output_dir, 'biomarker_config.json')
+    biomarker_config.save_to_file(biomarker_config_file)
+    logger.info(f"Biomarker configuration saved to: {biomarker_config_file}")
+    
+    logger.info(f"Model: {config.model}")
+    logger.info(f"Single-target strategy: {config.single_target_strategy}")
+    logger.info(f"Multi-target strategy: {config.multi_target_strategy}")
+    logger.info(f"Expected GPU memory: {config.expected_gpu_memory}")
+    logger.info(f"Training epochs: {epochs}")
+    logger.info(f"Data directory: {data_dir}")
+    logger.info(f"Biomarker configuration: {biomarker_config.experiment_name}")
+    logger.info(f"Total output size: {biomarker_config.total_output_size}")
+    logger.info(f"Seed: {seed}")
+    
+    # Create data transforms
+    train_transform = create_data_transforms(config, is_training=True)
+    val_transform = create_data_transforms(config, is_training=False)
+    
+    # Load datasets
+    logger.info("Loading datasets...")
+    train_dataset = ClassifierDataset(
+        data_dir, biomarker_config, transforms=train_transform, 
+        size=256, train=True
+    )
+    
+    val_dataset = ClassifierDataset(
+        data_dir, biomarker_config, transforms=val_transform,
+        size=256, train=False
+    )
+    
+    logger.info(f"Train dataset size: {len(train_dataset)}")
+    logger.info(f"Validation dataset size: {len(val_dataset)}")
+    
+    # Compute class weights if specified
+    class_weights = None
+    if config.class_weighting == 'inverse_frequency':
+        logger.info("Computing class weights...")
+        class_weights = compute_class_weights_for_dataset(train_dataset, biomarker_config)
+        logger.info(f"Class weights computed for {len(class_weights)} binary biomarkers")
+    
+    # Create data loaders
+    data_loader_generator = torch.Generator()
+    data_loader_generator.manual_seed(seed)
+
+    def _seed_worker(worker_id: int) -> None:
+        worker_seed = seed + worker_id
+        np.random.seed(worker_seed)
+        random.seed(worker_seed)
+        torch.manual_seed(worker_seed)
+
+    if config.sampling_strategy == 'balanced_batch':
+        train_sampler = create_balanced_sampler(train_dataset, biomarker_config)
+        train_loader = DataLoader(
+            train_dataset, batch_size=config.batch_size, 
+            sampler=train_sampler, num_workers=8, pin_memory=True,
+            worker_init_fn=_seed_worker, generator=data_loader_generator
+        )
+    else:
+        train_loader = DataLoader(
+            train_dataset, batch_size=config.batch_size, 
+            shuffle=True, num_workers=8, pin_memory=True,
+            worker_init_fn=_seed_worker, generator=data_loader_generator
+        )
+    
+    val_loader = DataLoader(
+        val_dataset, batch_size=config.batch_size, 
+        shuffle=False, num_workers=8, pin_memory=True,
+        worker_init_fn=_seed_worker, generator=data_loader_generator
+    )
+    
+    # Create model
+    logger.info("Creating model...")
+    model = ModelFactory.create_model(
+        architecture=config.model,
+        num_classes=biomarker_config.total_output_size,
+        pretrained_weights=config.pretrained_weights,
+        fine_tuning_strategy=config.fine_tuning_strategy,
+        dropout=config.dropout,
+        biomarker_config=biomarker_config,
+        single_target_strategy=config.single_target_strategy
+    )
+
+    model = model.to(device)
+
+    # Log model info
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    logger.info(f"Total parameters: {total_params:,}")
+    logger.info(f"Trainable parameters: {trainable_params:,}")
+    
+    # Create loss function - check if GradNorm is enabled
+    use_gradnorm = getattr(config, 'use_gradnorm', False)
+    gradnorm_trainer = None
+    
+    if use_gradnorm:
+        logger.info("Using GradNorm for loss balancing")
+        gradnorm_alpha = getattr(config, 'gradnorm_alpha', 0.16)
+        gradnorm_update_freq = getattr(config, 'gradnorm_update_freq', 10)
+        
+        gradnorm_loss = GradNormLoss(
+            biomarker_config=biomarker_config,
+            class_weights=class_weights,
+            alpha=gradnorm_alpha,
+            update_weights_every=gradnorm_update_freq,
+            initial_task_loss_average_window=20,
+            normalize_losses=True,
+            restoring_force_factor=0.1
+        )
+        gradnorm_loss = gradnorm_loss.to(device)  # Move to correct device
+        gradnorm_trainer = GradNormTrainer(gradnorm_loss)
+        criterion = gradnorm_loss  # For validation
+    else:
+        criterion = FlexibleMultiTaskLoss(biomarker_config, class_weights=class_weights)
+    
+    # Create optimizer and scheduler
+    # Note: GradNorm task weights are updated manually, not through optimizer
+    optimizer = create_optimizer(model.parameters(), config)
+    
+    scheduler = create_scheduler(optimizer, config, epochs)
+    
+    # Create metrics calculator
+    metrics_calc = FlexibleMetricsCalculator(biomarker_config)
+    
+    # Training loop
+    best_median_auroc = 0.0
+    best_mae = float('inf')  # Initialize MAE tracking for continuous-only scenarios
+    best_epoch = 0
+    patience = 10
+    patience_counter = 0
+    
+    # Determine task types for logging and selection
+    has_classification_tasks = (len(biomarker_config.binary_biomarkers) > 0 or 
+                               len(biomarker_config.multiclass_biomarkers) > 0)
+    has_continuous_tasks = len(biomarker_config.continuous_biomarkers) > 0
+    
+    logger.info(f"Starting training for {epochs} epochs with early stopping (patience: {patience})")
+    if has_classification_tasks and has_continuous_tasks:
+        logger.info("Multi-task training: Classification + Regression")
+    elif has_classification_tasks:
+        logger.info("Classification training: Using median AUROC for best model selection")
+    elif has_continuous_tasks:
+        logger.info("Regression training: Using MAE for best model selection")
+    
+    for epoch in range(epochs):
+        epoch_start_time = time.time()
+        
+        training_logger.info(f"Starting Epoch {epoch+1}/{epochs}")
+        
+        # Training phase
+        train_loss, train_metrics, train_loss_components = train_epoch(
+            model, train_loader, criterion, optimizer, device, metrics_calc, gradnorm_trainer
+        )
+        
+        # Validation phase
+        val_loss, val_metrics, val_loss_components = validate_epoch(
+            model, val_loader, criterion, device, metrics_calc
+        )
+        
+        # Update scheduler
+        if isinstance(scheduler, torch.optim.lr_scheduler.ReduceLROnPlateau):
+            scheduler.step(val_loss)
+        else:
+            scheduler.step()
+        
+        epoch_time = time.time() - epoch_start_time
+        
+        # Log to tensorboard
+        writer.add_scalar('Loss/Train', train_loss, epoch)
+        writer.add_scalar('Loss/Validation', val_loss, epoch)
+        writer.add_scalar('Metrics/Average_AUROC_Train', train_metrics['average_auroc'], epoch)
+        writer.add_scalar('Metrics/Average_AUROC_Val', val_metrics['average_auroc'], epoch)
+        writer.add_scalar('Metrics/Median_AUROC_Train', train_metrics['median_auroc'], epoch)
+        writer.add_scalar('Metrics/Median_AUROC_Val', val_metrics['median_auroc'], epoch)
+        writer.add_scalar('Learning_Rate', optimizer.param_groups[0]['lr'], epoch)
+        
+        # Log GradNorm weights if using GradNorm
+        if gradnorm_trainer is not None:
+            gradnorm_stats = gradnorm_trainer.get_training_stats()
+            task_weights = gradnorm_stats['task_weights']
+            
+            for task_name, weight in task_weights.items():
+                writer.add_scalar(f'GradNorm_Weights/{task_name}', weight, epoch)
+            
+            # Log GradNorm info
+            if gradnorm_stats['initial_losses_computed']:
+                training_logger.info(f"GradNorm task weights: {task_weights}")
+        
+        # Log individual biomarker metrics
+        for biomarker in biomarker_config.binary_biomarkers:
+            if biomarker.name in train_metrics and biomarker.name in val_metrics:
+                train_biomarker_metrics = train_metrics[biomarker.name]
+                val_biomarker_metrics = val_metrics[biomarker.name]
+                
+                if 'auroc' in train_biomarker_metrics and 'auroc' in val_biomarker_metrics:
+                    writer.add_scalar(f'AUROC_Train/{biomarker.name}', train_biomarker_metrics['auroc'], epoch)
+                    writer.add_scalar(f'AUROC_Val/{biomarker.name}', val_biomarker_metrics['auroc'], epoch)
+        
+        # Log epoch results
+        training_logger.info(f"Epoch {epoch+1} completed in {epoch_time:.2f}s")
+        training_logger.info(f"Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}")
+        training_logger.info(f"Train Avg AUROC: {train_metrics['average_auroc']:.4f}, Val Avg AUROC: {val_metrics['average_auroc']:.4f}")
+        training_logger.info(f"Train Median AUROC: {train_metrics['median_auroc']:.4f}, Val Median AUROC: {val_metrics['median_auroc']:.4f}")
+        
+        # Log individual biomarker validation metrics
+        training_logger.info("Validation metrics per biomarker:")
+        for biomarker in biomarker_config.binary_biomarkers:
+            if biomarker.name in val_metrics:
+                biomarker_metrics = val_metrics[biomarker.name]
+                if 'auroc' in biomarker_metrics and 'accuracy' in biomarker_metrics:
+                    training_logger.info(f"  {biomarker.name}: AUROC={biomarker_metrics['auroc']:.4f}, "
+                                       f"Acc={biomarker_metrics['accuracy']:.4f}, "
+                                       f"F1={biomarker_metrics.get('f1', 0.0):.4f}")
+        
+        # Log multiclass biomarker metrics if any exist
+        for biomarker in biomarker_config.multiclass_biomarkers:
+            if biomarker.name in val_metrics:
+                biomarker_metrics = val_metrics[biomarker.name]
+                if 'accuracy' in biomarker_metrics:
+                    training_logger.info(f"  {biomarker.name}: Acc={biomarker_metrics['accuracy']:.4f}, "
+                                       f"F1={biomarker_metrics.get('f1_weighted', 0.0):.4f}")
+        
+        # Log continuous biomarker metrics if any exist
+        for biomarker in biomarker_config.continuous_biomarkers:
+            if biomarker.name in val_metrics:
+                biomarker_metrics = val_metrics[biomarker.name]
+                if 'mse' in biomarker_metrics:
+                    training_logger.info(f"  {biomarker.name}: MSE={biomarker_metrics['mse']:.4f}, "
+                                       f"MAE={biomarker_metrics.get('mae', 0.0):.4f}")
+        
+        # Save checkpoint if best model
+        # Use MAE for continuous-only scenarios, AUROC for classification scenarios
+        
+        if has_classification_tasks:
+            # Use median AUROC for classification scenarios
+            # Check if we actually have AUROC values (not just 0.0)
+            if val_metrics['median_auroc'] > 0.0:
+                is_best = val_metrics['median_auroc'] > best_median_auroc
+                if is_best:
+                    best_median_auroc = val_metrics['median_auroc']
+                    best_epoch = epoch + 1
+                    patience_counter = 0  # Reset patience counter
+                    training_logger.info(f"New best model! Median AUROC: {best_median_auroc:.4f} (Avg: {val_metrics['average_auroc']:.4f})")
+                else:
+                    patience_counter += 1
+                    training_logger.info(f"No improvement. Patience: {patience_counter}/{patience}")
+                    
+                    # Early stopping check
+                    if patience_counter >= patience:
+                        training_logger.info("Early stopping triggered!")
+                        break
+            else:
+                # No actual AUROC values available - fall back to MAE if continuous tasks exist
+                if has_continuous_tasks:
+                    training_logger.warning("No AUROC values available for classification tasks, falling back to MAE for model selection")
+                    # Use MAE logic (will be handled in the elif block below)
+                    pass
+                else:
+                    # No meaningful metrics available
+                    is_best = False
+                    patience_counter += 1
+                    training_logger.warning("No AUROC values available and no continuous tasks - cannot determine best model")
+        elif has_continuous_tasks:
+            # Use MAE for continuous-only scenarios (lower MAE is better)
+            mae_values = []
+            for biomarker in biomarker_config.continuous_biomarkers:
+                if biomarker.name in val_metrics:
+                    mae = val_metrics[biomarker.name].get('mae', float('inf'))
+                    mae_values.append(mae)
+                    training_logger.info(f"  {biomarker.name}: MAE={mae:.4f}")
+            
+            if mae_values:
+                current_mae = np.mean(mae_values)
+                is_best = current_mae < best_mae
+                if is_best:
+                    best_mae = current_mae
+                    best_epoch = epoch + 1
+                    patience_counter = 0  # Reset patience counter
+                    training_logger.info(f"New best model! Average MAE: {best_mae:.4f}")
+                else:
+                    patience_counter += 1
+                    training_logger.info(f"No improvement. Current MAE: {current_mae:.4f}, Best MAE: {best_mae:.4f}. Patience: {patience_counter}/{patience}")
+                    
+                    # Early stopping check
+                    if patience_counter >= patience:
+                        training_logger.info("Early stopping triggered!")
+                        break
+            else:
+                # Fallback if no MAE values available
+                is_best = False
+                patience_counter += 1
+                training_logger.warning("No MAE values available for continuous biomarkers")
+        else:
+            # No biomarkers configured - should not happen
+            is_best = False
+            training_logger.error("No biomarkers configured!")
+            break
+        
+        # Save checkpoint
+        checkpoint = {
+            'epoch': epoch + 1,
+            'model_state_dict': model.state_dict(),
+            'optimizer_state_dict': optimizer.state_dict(),
+            'scheduler_state_dict': scheduler.state_dict(),
+            'train_loss': train_loss,
+            'val_loss': val_loss,
+            'train_metrics': train_metrics,
+            'val_metrics': val_metrics,
+            'config': config.to_dict(),
+            'biomarker_config': biomarker_config.experiment_name,
+            'best_median_auroc': best_median_auroc,
+            'best_mae': best_mae,
+            'best_epoch': best_epoch,
+            'optimal_thresholds': metrics_calc.optimal_thresholds  # Save optimal thresholds
+        }
+        
+        # Save latest and best checkpoints
+        torch.save(checkpoint, os.path.join(output_dir, 'latest_checkpoint.pth'))
+        if is_best:
+            torch.save(checkpoint, os.path.join(output_dir, 'best_checkpoint.pth'))
+    
+    # Close tensorboard writer
+    writer.close()
+    
+    # Final logging based on task type and actual metrics used
+    if has_classification_tasks and best_median_auroc > 0.0:
+        # Classification tasks with actual AUROC values
+        logger.info(f"Training completed! Best model at epoch {best_epoch} with Median AUROC: {best_median_auroc:.4f}")
+        return model, best_median_auroc
+    elif has_continuous_tasks:
+        # Continuous tasks (either only continuous, or classification tasks fell back to MAE)
+        logger.info(f"Training completed! Best model at epoch {best_epoch} with MAE: {best_mae:.4f}")
+        return model, best_mae
+    else:
+        # No meaningful metrics available
+        logger.info(f"Training completed! Best model at epoch {best_epoch} (no meaningful metrics available)")
+        return model, 0.0
+
+
+def main():
+    parser = ArgumentParser(description='Flexible Multi-Task Training')
+
+    # --- Required arguments ---
+    parser.add_argument('--model', required=True,
+                        help='Model architecture to train (e.g. "ResNet-18", "ViT-Small (DINOv2)"). '
+                             'See README for the full list of supported models.')
+    parser.add_argument('--data_dir', required=True,
+                        help='Path to dataset directory. Must contain train.csv, val.csv, and a data/ subfolder with PNG images.')
+    parser.add_argument('--biomarker_config', required=True,
+                        help='Path to biomarker configuration file (YAML or JSON). '
+                             'See config/biomarker_config_multitask_example.yaml for the full multi-task config used in the paper.')
+
+    # --- Output ---
+    parser.add_argument('--output_dir', default='./outputs',
+                        help='Directory to save checkpoints, logs, and TensorBoard (default: ./outputs)')
+    parser.add_argument('--experiment_name',
+                        help='Custom name for this run. Auto-generated from model/lr/batch if not provided.')
+
+    # --- Training hyperparameters (defaults match the published experiments) ---
+    parser.add_argument('--epochs', type=int, default=100,
+                        help='Number of training epochs (default: 100)')
+    parser.add_argument('--learning_rate', type=float, default=1e-4,
+                        help='Learning rate (default: 1e-4)')
+    parser.add_argument('--batch_size', type=int, default=16,
+                        help='Batch size (default: 16)')
+    parser.add_argument('--weight_decay', type=float, default=1e-4,
+                        help='Weight decay (default: 1e-4)')
+    parser.add_argument('--optimizer', default='AdamW', choices=['AdamW', 'Adam', 'SGD'],
+                        help='Optimizer (default: AdamW)')
+    parser.add_argument('--scheduler', default='CosineAnnealing',
+                        choices=['CosineAnnealing', 'CosineAnnealingWarmRestarts',
+                                 'ReduceLROnPlateau', 'StepLR', 'ExponentialLR'],
+                        help='LR scheduler (default: CosineAnnealing)')
+    parser.add_argument('--dropout', type=float, default=0.2,
+                        help='Dropout rate (default: 0.2)')
+    parser.add_argument('--class_weighting', default='inverse_frequency',
+                        choices=['inverse_frequency', 'none'],
+                        help='Class weighting strategy (default: inverse_frequency)')
+    parser.add_argument('--sampling_strategy', default='balanced_batch',
+                        choices=['balanced_batch', 'random'],
+                        help='Sampling strategy for training DataLoader (default: balanced_batch)')
+    parser.add_argument('--fine_tuning_strategy', default='Full fine-tuning',
+                        choices=['Full fine-tuning', 'full', 'linear_probe'],
+                        help='Fine-tuning strategy (default: Full fine-tuning)')
+    parser.add_argument('--seed', type=int, default=42,
+                        help='Global random seed for reproducibility (default: 42)')
+    parser.add_argument('--deterministic', action='store_true',
+                        help='Enable deterministic backend behavior (can reduce throughput)')
+
+    # --- Per-model defaults (auto-detected from model name if not specified) ---
+    parser.add_argument('--pretrained_weights',
+                        help='Pretrained weights to use. Auto-detected from --model if not provided.')
+    parser.add_argument('--single_target_strategy',
+                        help='Single-target strategy. Auto-detected from --model if not provided.')
+
+    # --- GradNorm ---
+    parser.add_argument('--use_gradnorm', action='store_true',
+                        help='Enable GradNorm adaptive loss balancing')
+    parser.add_argument('--gradnorm_alpha', type=float, default=0.16,
+                        help='GradNorm restoring force strength (default: 0.16)')
+    parser.add_argument('--gradnorm_update_freq', type=int, default=10,
+                        help='Update GradNorm weights every N iterations (default: 10)')
+
+    args = parser.parse_args()
+    set_global_seed(args.seed, deterministic=args.deterministic)
+
+    # Load biomarker configuration
+    print(f"Loading biomarker configuration from: {args.biomarker_config}")
+    biomarker_config = FlexibleBiomarkerConfig(args.biomarker_config)
+
+    print("Biomarker configuration loaded:")
+    biomarker_config.print_summary()
+
+    # Resolve per-model defaults for pretrained_weights and single_target_strategy
+    model_defaults = get_model_defaults(args.model)
+    pretrained_weights = args.pretrained_weights or model_defaults['pretrained_weights']
+    single_target_strategy = args.single_target_strategy or model_defaults['single_target_strategy']
+    fine_tuning_strategy = normalize_fine_tuning_strategy(args.fine_tuning_strategy)
+
+    # Build ExperimentConfig directly from CLI args
+    config = ExperimentConfig(
+        model=args.model,
+        loss_function='CE',
+        must_include=True,
+        learning_rate=[args.learning_rate],
+        batch_size=args.batch_size,
+        weight_decay=args.weight_decay,
+        optimizer=args.optimizer,
+        scheduler=args.scheduler,
+        image_augmentations=DEFAULT_AUGMENTATIONS.copy(),
+        dropout=args.dropout,
+        loss_specific_params='class_weights=inverse_frequency',
+        multi_target_strategy='Shared backbone + task-specific heads',
+        single_target_strategy=single_target_strategy,
+        pretrained_weights=pretrained_weights,
+        fine_tuning_strategy=fine_tuning_strategy,
+        expected_gpu_memory='',
+        architectural_family='',
+        class_weighting=args.class_weighting,
+        sampling_strategy=args.sampling_strategy,
+        threshold_selection='F1_optimal',
+        experiment_name=args.experiment_name or '',
+        use_gradnorm=args.use_gradnorm,
+        gradnorm_alpha=args.gradnorm_alpha,
+        gradnorm_update_freq=args.gradnorm_update_freq,
+    )
+
+    output_dir = os.path.join(args.output_dir, config.experiment_name)
+
+    print(f"\n{'='*50}")
+    print(f"Training: {config.model}")
+    print(f"  Pretrained weights:      {pretrained_weights}")
+    print(f"  Single-target strategy:  {single_target_strategy}")
+    print(f"  Learning rate:           {args.learning_rate}")
+    print(f"  Batch size:              {args.batch_size}")
+    print(f"  Epochs:                  {args.epochs}")
+    print(f"  Seed:                    {args.seed}")
+    print(f"  Deterministic:           {args.deterministic}")
+    print(f"  Output dir:              {output_dir}")
+    print(f"{'='*50}\n")
+
+    train_model(
+        config=config,
+        data_dir=args.data_dir,
+        output_dir=output_dir,
+        biomarker_config=biomarker_config,
+        epochs=args.epochs,
+        seed=args.seed,
+    )
+
+
+if __name__ == "__main__":
+    main()

code/utils/checkpoints.py

@@ -0,0 +1,61 @@
+import os
+import shutil
+import logging
+import torch
+
+# Functions in this file are inspired by the following:
+# https://github.com/cs230-stanford/cs230-code-examples/blob/master/pytorch/vision/utils.py
+
+logger = logging.getLogger(__name__)
+
+
+def save_checkpoint(state, model_state, isbest, checkpoint):
+    """
+    Save training and model state to a checkpoint directory.
+    """
+    filepath = os.path.join(checkpoint, 'last.pth')
+    model_filepath = os.path.join(checkpoint, 'model_last.pth')
+    if not os.path.exists(checkpoint):
+        logger.info("Checkpoint directory does not exist. Creating %s", checkpoint)
+        os.makedirs(checkpoint)
+
+    torch.save(state, filepath)
+    torch.save(model_state, model_filepath)
+    if isbest:
+        logger.info("Saving best checkpoint copy")
+        shutil.copyfile(filepath, os.path.join(checkpoint, 'best.pth'))
+        shutil.copyfile(model_filepath, os.path.join(checkpoint, 'model_best.pth'))
+
+
+def load_checkpoint(checkpoint, model, optimizer=None):
+    """
+    Load checkpoint file into model (and optimizer if provided).
+
+    The key remapping logic below is kept for compatibility with older
+    checkpoint formats used during project development.
+    """
+    if not os.path.exists(checkpoint):
+        raise IOError("File doesn't exist {}".format(checkpoint))
+
+    if torch.cuda.is_available():
+        checkpoint = torch.load(checkpoint)
+    else:
+        checkpoint = torch.load(checkpoint, map_location='cpu')
+
+    state_dict = {}
+    for key in checkpoint['state_dict'].keys():
+        if 'layers.0.' in key:
+            state_dict[key.split('0.')[0].split('module.')[1] + key.split('0.')[1]] = checkpoint['state_dict'][key]
+        elif 'layers.1.' in key:
+            state_dict[key.replace('1', '8').split('module.')[1]] = checkpoint['state_dict'][key]
+        elif 'module.' in key:
+            state_dict[key.split('module.')[1]] = checkpoint['state_dict'][key]
+        else:
+            state_dict[key] = checkpoint['state_dict'][key]
+    model.load_state_dict(state_dict)
+
+    if optimizer:
+        optimizer.load_state_dict(checkpoint['optim_dict'])
+
+    return checkpoint
+

code/utils/labels.py

@@ -0,0 +1,15 @@
+from enum import IntEnum
+
+class Condition(IntEnum):
+    ABSENT = 0
+    PRESENT = 1
+
+    @staticmethod
+    def convert(s):
+        value = str(s).upper()
+        if value == 'ABSENT':
+            return Condition.ABSENT
+        if value == 'PRESENT':
+            return Condition.PRESENT
+        raise ValueError(f"Unsupported condition label: {s}")
+