""" 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()