code/test.py

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