import sys import os import json import time import random from tqdm import tqdm import numpy as np import torch import torch.nn as nn from torch.nn import functional as F import torch.optim as optim from torch.utils.data import Dataset, DataLoader import matplotlib.pyplot as plt from sklearn.calibration import calibration_curve from scipy import stats import torchvision.models as models import torchvision # Add project paths current_dir = os.path.dirname(os.path.abspath(__file__)) parent_dir = os.path.dirname(current_dir) grandparent_dir = os.path.dirname(parent_dir) sys.path.append(grandparent_dir) sys.path.append(parent_dir) # Calibrator imports from calibrator.Component.model.pts import PTSCalibrator from calibrator.Component.model.cts import CTSCalibrator from calibrator.Component.model.temperature_scaling import TemperatureScalingCalibrator from calibrator.Component.model.ets import ETSCalibrator from calibrator.Component.model.histogram_binning import HistogramBinningCalibrator from calibrator.Component.model.bbq import BBQCalibrator from calibrator.Component.model.vector_scaling import VectorScalingCalibrator from calibrator.Component.model.group_calibration import GroupCalibrationCalibrator from calibrator.Component.model.procal import ProCalDensityRatioCalibrator, ProCalBinMeanShiftCalibrator from calibrator.Component.model.feature_clipping import FeatureClippingCalibrator from calibrator.Component.model.logit_clipping import LogitClippingCalibrator from calibrator.Component.model.density_aware_calibration import DensityAwareCalibrator from calibrator.Component.metrics.WeightedSoftECE import WeightedSoftECE from calibrator.Component.metrics.SmoothSoftECE import SmoothSoftECE from calibrator.Component.metrics.GapIndexedSoftECE import GapIndexedSoftECE # Metrics imports from calibrator.Component.metrics import ( BrierLoss, FocalLoss, LabelSmoothingLoss, CrossEntropyLoss, MSELoss, SoftECE, ECE, AdaptiveECE, ClasswiseECE, Accuracy, NLL, KDEECE, ECEDebiased, ECESweep ) from calibrator.Component.utils.utils import get_all_metrics, get_all_metrics_multi_bins from Datasets.imagenet import get_data_loader # Import models dictionary from utils from utils import models_dict, dataset_loader, dataset_num_classes # Import visualization functions from plotting.visualization import ( plot_enhanced_calibration_curve, plot_logitsgap_analysis, plot_temperature_distribution, plot_logitsgap_temperature_relationship, plot_confidence_distribution, plot_confidence_change, plot_logitsgap_by_correctness, plot_performance_by_logitsgap ) # Import SMART calibration functionality from utils.smart_calibrator import SMART, compute_logitsgap, set_seed # Import from split utility modules from utils.model_utils import get_model_normalization, get_model_input_size, create_model from utils.data_utils import ( get_logit_paths, logits_exist, load_logits, save_logits, create_train_loader_for_dac, extract_train_features_for_dac ) # Constants BINS_LIST = [5, 10, 15, 20, 25, 30] AVAILABLE_METRICS = ['ece', 'adaece', 'cece', 'ece_debiased', 'ece_sweep', 'nll', 'accuracy', 'kde_ece', 'rbs'] DEFAULT_METRICS = ['ece', 'adaece', 'cece', 'nll', 'accuracy', 'rbs'] def get_model_and_logits(args, model_name='resnet50', batch_size=32, num_workers=4, use_cuda=True, dataset_name='imagenet', seed_value=1, valid_size=0.2, loss_fn='CE'): """ Get a pretrained model and compute logits for calibration and test sets Args: args: Command line arguments model_name: Name of the pretrained model to use batch_size: Batch size for data loading num_workers: Number of workers for data loading use_cuda: Whether to use CUDA (GPU) for computation dataset_name: Name of the dataset seed_value: Random seed used valid_size: Validation set size loss_fn: Loss function used for calibration Returns: Logits and labels for calibration and test sets """ # Extract corruption parameters for ImageNet-C corruption_type = getattr(args, 'corruption_type', None) if dataset_name == 'imagenet_c' else None severity = getattr(args, 'severity', None) if dataset_name == 'imagenet_c' else None # Get train_loss for CIFAR datasets train_loss = args.train_loss if dataset_name.startswith('cifar') else None # Check if logits already exist if logits_exist(dataset_name, model_name, seed_value, valid_size, loss_fn, corruption_type, severity, train_loss): dataset_info = f"{dataset_name}" if dataset_name == 'imagenet_c' and corruption_type is not None and severity is not None: dataset_info = f"{dataset_name} (corruption: {corruption_type}, severity: {severity})" print(f"Logits already exist for {dataset_info}, {model_name}, seed {seed_value}, valid_size {valid_size}") return load_logits(dataset_name, model_name, seed_value, valid_size, loss_fn, corruption_type, severity, train_loss) device = torch.device("cuda" if use_cuda and torch.cuda.is_available() else "cpu") print(f"Using device: {device}") # Define required arguments if not provided in args if not hasattr(args, 'valid_size'): args.valid_size = valid_size if not hasattr(args, 'random_seed'): args.random_seed = seed_value if not hasattr(args, 'test_batch_size'): args.test_batch_size = batch_size if not hasattr(args, 'train_batch_size'): args.train_batch_size = batch_size if not hasattr(args, 'dataset_root'): args.dataset_root = '/hdd/haolan/datasets/' if not hasattr(args, 'corruption_type') and dataset_name == 'imagenet_c': args.corruption_type = 'gaussian_noise' corruption_type = 'gaussian_noise' if not hasattr(args, 'severity') and dataset_name == 'imagenet_c': args.severity = 1 severity = 1 if not hasattr(args, 'train_loss'): args.train_loss = 'cross_entropy' # Load model using the helper function try: model = create_model(args, args.model, args.dataset, device) print(f"Loaded model: {model.__class__.__name__}") except Exception as e: print(f"Error loading model: {e}") raise # Set model to eval mode model.eval() # Fix for accessing classifier or fc attributes if hasattr(model, 'module'): # Check if model is wrapped with DataParallel if hasattr(model.module, 'classifier'): model.classifier = model.module.classifier elif hasattr(model.module, 'fc'): model.fc = model.module.fc # Get model-specific normalization and input size norm_mean, norm_std = get_model_normalization(model_name) input_size = get_model_input_size(model_name) print(f"Using normalization for {model_name}: mean={norm_mean}, std={norm_std}") print(f"Using input size for {model_name}: {input_size}x{input_size}") # Get appropriate data loaders based on dataset try: val_loader = None test_loader = None if args.dataset == 'imagenet': val_loader = dataset_loader['imagenet'].get_data_loader( root=args.dataset_root, split='val', batch_size=args.test_batch_size, shuffle=True, valid_size=args.valid_size, num_workers=16, pin_memory=True, random_seed=args.random_seed, mean=norm_mean, std=norm_std, image_size=input_size ) test_loader = dataset_loader['imagenet'].get_data_loader( root=args.dataset_root, split='test', batch_size=args.test_batch_size, shuffle=True, valid_size=args.valid_size, num_workers=16, pin_memory=True, random_seed=args.random_seed, mean=norm_mean, std=norm_std, image_size=input_size ) elif args.dataset in ['cifar10', 'cifar100']: _, val_loader = dataset_loader[args.dataset].get_train_valid_loader( root=args.dataset_root, batch_size=args.train_batch_size, shuffle=True, random_seed=1, augment=True ) test_loader = dataset_loader[args.dataset].get_test_loader( root=args.dataset_root, batch_size=args.test_batch_size, shuffle=False ) elif args.dataset == 'imagenet_c': # For ImageNet-C, we have both validation and test sets val_loader, test_loader = dataset_loader[args.dataset].get_imagenet_c_data_loader( root="/hdd/haolan/datasets/ImageNet-C/", batch_size=args.test_batch_size, corruption_type=args.corruption_type, severity=args.severity, num_workers=16, pin_memory=True, valid_size=args.valid_size, random_seed=args.random_seed, mean=norm_mean, std=norm_std, image_size=input_size ) elif args.dataset == 'imagenet_lt': val_loader, test_loader = dataset_loader[args.dataset].get_imagenet_lt_data_loader( root="/hdd/haolan/datasets/ImageNet-LT/", batch_size=args.test_batch_size, num_workers=16, pin_memory=True, valid_size=args.valid_size, random_seed=args.random_seed, mean=norm_mean, std=norm_std, image_size=input_size ) elif args.dataset == 'imagenet_sketch': val_loader, test_loader = dataset_loader[args.dataset].get_imagenet_sketch_data_loader( root="/hdd/haolan/datasets/ImageNet-Sketch/", batch_size=args.test_batch_size, num_workers=16, pin_memory=True, valid_size=args.valid_size, random_seed=args.random_seed, mean=norm_mean, std=norm_std, image_size=input_size ) elif args.dataset == 'iwildcam': val_loader = dataset_loader[args.dataset].get_data_loader( root="/hdd/datasets/wilds/iwildcam_v2.0", split='val', batch_size=args.test_batch_size, shuffle=False, num_workers=16, pin_memory=True, mean=norm_mean, std=norm_std, image_size=input_size ) test_loader = dataset_loader[args.dataset].get_data_loader( root="/hdd/datasets/wilds/iwildcam_v2.0", split='test', batch_size=args.test_batch_size, shuffle=False, num_workers=16, pin_memory=True, mean=norm_mean, std=norm_std, image_size=input_size ) else: raise ValueError(f"Dataset {args.dataset} not supported") # Check if loaders were created successfully if val_loader is None or test_loader is None: raise ValueError(f"Failed to create data loaders for dataset {args.dataset}") except Exception as e: print(f"Error creating data loaders: {e}") raise # Compute logits and features val_logits = [] val_labels = [] val_features = [] test_logits = [] test_labels = [] test_features = [] print("Computing logits and features for calibration set...") with torch.no_grad(): for inputs, labels in tqdm(val_loader): inputs = inputs.to(device) # Get features from model (all models should support return_features=True now) outputs, features = model(inputs, return_features=True) val_features.append(features.cpu().numpy()) val_logits.append(outputs.cpu().numpy()) val_labels.append(labels.numpy()) print("Computing logits and features for test set...") with torch.no_grad(): for inputs, labels in tqdm(test_loader): inputs = inputs.to(device) # Get features from model (all models should support return_features=True now) outputs, features = model(inputs, return_features=True) test_features.append(features.cpu().numpy()) test_logits.append(outputs.cpu().numpy()) test_labels.append(labels.numpy()) val_logits = np.vstack(val_logits) val_labels = np.hstack(val_labels) val_features = np.vstack(val_features) test_logits = np.vstack(test_logits) test_labels = np.hstack(test_labels) test_features = np.vstack(test_features) # Save logits with parameter-specific filenames save_logits(val_logits, val_labels, test_logits, test_labels, val_features, test_features, dataset_name, model_name, seed_value, valid_size, loss_fn, corruption_type, severity, train_loss) return val_logits, val_labels, test_logits, test_labels, val_features, test_features def compute_and_print_metrics(logits, labels, method_name, bins_list=None, device='cuda', enabled_metrics=None): """ Compute and print metrics for a calibration method Args: logits: torch.Tensor - calibrated logits or probabilities labels: torch.Tensor - ground truth labels method_name: str - name of the calibration method bins_list: list - list of bin sizes for evaluation device: str - device to use for computation enabled_metrics: list - list of metrics to compute and print Returns: dict: computed metrics """ if bins_list is None: bins_list = BINS_LIST if enabled_metrics is None: enabled_metrics = DEFAULT_METRICS # Move tensors to device logits = logits.to(device) labels = labels.to(device) # Determine if logits are actually probabilities is_probs = (logits.dim() == 2 and torch.allclose(logits.sum(dim=1), torch.ones(logits.size(0), device=device), atol=1e-3)) # Use get_all_metrics_multi_bins function from utils to calculate all metrics all_metrics = get_all_metrics_multi_bins( labels=labels, logits=logits if not is_probs else None, probs=logits if is_probs else None, bins_list=bins_list ) # Print metrics based on enabled_metrics metric_strs = [] if 'accuracy' in enabled_metrics: metric_strs.append(f"Accuracy: {all_metrics['accuracy']:.4f}") if any(metric.startswith('ece') for metric in enabled_metrics): ece_strs = [] for bins in bins_list: if 'ece' in enabled_metrics and f'ece_{bins}' in all_metrics: ece_strs.append(f"ECE_{bins}: {all_metrics[f'ece_{bins}']:.4f}") if ece_strs: metric_strs.append(", ".join(ece_strs)) if any(metric.startswith('adaece') for metric in enabled_metrics): adaece_strs = [] for bins in bins_list: if 'adaece' in enabled_metrics and f'adaece_{bins}' in all_metrics: adaece_strs.append(f"AdaECE_{bins}: {all_metrics[f'adaece_{bins}']:.4f}") if adaece_strs and len(bins_list) <= 3: # Only show for small bin lists to avoid clutter metric_strs.append(", ".join(adaece_strs)) if any(metric.startswith('cece') for metric in enabled_metrics): cece_strs = [] for bins in bins_list: if 'cece' in enabled_metrics and f'cece_{bins}' in all_metrics: cece_strs.append(f"CECE_{bins}: {all_metrics[f'cece_{bins}']:.4f}") if cece_strs and len(bins_list) <= 3: # Only show for small bin lists to avoid clutter metric_strs.append(", ".join(cece_strs)) if any(metric.startswith('ece_debiased') for metric in enabled_metrics): debiased_strs = [] for bins in bins_list: if 'ece_debiased' in enabled_metrics and f'ece_debiased_{bins}' in all_metrics: debiased_strs.append(f"ECE_Debiased_{bins}: {all_metrics[f'ece_debiased_{bins}']:.4f}") if debiased_strs: metric_strs.append(", ".join(debiased_strs)) if 'ece_sweep' in enabled_metrics and 'ece_sweep' in all_metrics: metric_strs.append(f"ECE_Sweep: {all_metrics['ece_sweep']:.4f}") if 'kde_ece' in enabled_metrics: # Add KDE ECE metric if requested try: kde_ece_metric = KDEECE(p=1, mc_type='top_label', bandwidth=0.0268) if not is_probs: # logits kde_ece_value = kde_ece_metric(logits=logits, labels=labels) else: # probabilities - convert to pseudo-logits pseudo_logits = torch.log(logits + 1e-8) kde_ece_value = kde_ece_metric(logits=pseudo_logits, labels=labels) all_metrics['kde_ece'] = float(kde_ece_value.item()) metric_strs.append(f"KDE ECE: {all_metrics['kde_ece']:.4f}") except: all_metrics['kde_ece'] = -1 if 'kde_ece' in enabled_metrics: metric_strs.append("KDE ECE: -1.0000 (failed)") if 'nll' in enabled_metrics: metric_strs.append(f"NLL: {all_metrics['nll']:.4f}") if 'rbs' in enabled_metrics and 'rbs' in all_metrics: metric_strs.append(f"RBS: {all_metrics['rbs']:.4f}") print(f"{method_name} - {', '.join(metric_strs)}") return all_metrics def store_method_results(overall_results, method_key, all_metrics, bins_list=None, loss_fn=None, additional_params=None): """ Store method results in the overall_results dictionary Args: overall_results: dict - the overall results dictionary method_key: str - key for storing results (e.g., 'TS_CE', 'SMART_soft_ece') all_metrics: dict - computed metrics bins_list: list - list of bin sizes loss_fn: str - loss function used additional_params: dict - additional parameters to store """ if bins_list is None: bins_list = BINS_LIST method_results = { 'acc': float(all_metrics['accuracy']), 'nll': float(all_metrics['nll']), 'loss_fn': loss_fn or 'none' } # Add additional parameters if additional_params: method_results.update(additional_params) # Add bin-specific metrics for bins in bins_list: if f'ece_{bins}' in all_metrics: method_results[f'ece_{bins}'] = float(all_metrics[f'ece_{bins}']) if f'adaece_{bins}' in all_metrics: method_results[f'adaece_{bins}'] = float(all_metrics[f'adaece_{bins}']) if f'cece_{bins}' in all_metrics: method_results[f'cece_{bins}'] = float(all_metrics[f'cece_{bins}']) if f'ece_debiased_{bins}' in all_metrics: method_results[f'ece_debiased_{bins}'] = float(all_metrics[f'ece_debiased_{bins}']) # Add non-bin specific metrics if 'ece_sweep' in all_metrics: method_results['ece_sweep'] = float(all_metrics['ece_sweep']) if 'kde_ece' in all_metrics: method_results['kde_ece'] = float(all_metrics['kde_ece']) if 'rbs' in all_metrics: method_results['rbs'] = float(all_metrics['rbs']) # Keep backward compatibility metrics (using 15 bins) method_results['ece'] = float(all_metrics.get('ece_15', 0)) method_results['adaece'] = float(all_metrics.get('adaece_15', 0)) method_results['cece'] = float(all_metrics.get('cece_15', 0)) method_results['ece_debiased'] = float(all_metrics.get('ece_debiased_15', 0)) overall_results['overall'][method_key] = method_results def generate_visualizations(test_logits, test_labels, calibration_plots, logitsgap_values=None, temperatures=None, optimal_temp=None, methods_run=None, model_name="Model", plot_dir="plots"): """ Generate visualization plots for calibration methods Args: test_logits: Logits for the test set test_labels: Labels for the test set calibration_plots: Dictionary mapping method names to probability arrays logitsgap_values: List of sample logitsgap values (optional) temperatures: List of temperatures generated by SMART (optional) optimal_temp: Optimal temperature found by TS method (optional) methods_run: List of calibration methods run model_name: Name of the model plot_dir: Directory to save plots """ if methods_run is None or len(methods_run) == 0: print("No calibration methods to visualize") return # Ensure directory exists os.makedirs(plot_dir, exist_ok=True) # 1. Plot calibration curves for each method individually for method in methods_run: method_key = None if method == "uncalibrated" and "Uncalibrated" in calibration_plots: method_key = "Uncalibrated" filename = "Uncalibrated" elif method == "TS" and "TS" in calibration_plots: method_key = "TS" filename = "Temperature_Scaling" elif method == "PTS" and "PTS" in calibration_plots: method_key = "PTS" filename = "Parametric_Temperature_Scaling" elif method == "CTS" and "CTS" in calibration_plots: method_key = "CTS" filename = "Class_Temperature_Scaling" elif method == "ETS" and "ETS" in calibration_plots: method_key = "ETS" filename = "Ensemble_Temperature_Scaling" elif method == "SMART" and "SMART" in calibration_plots: method_key = "SMART" filename = "SMART" if method_key: plot_enhanced_calibration_curve( calibration_plots[method_key], test_labels, filename, plot_dir ) # 2. If logitsgap values exist, plot logitsgap analysis if logitsgap_values is not None and len(logitsgap_values) > 0: plot_logitsgap_analysis(logitsgap_values, model_name, plot_dir) # 3. If both SMART-generated temperatures and logitsgap exist, plot their relationship if temperatures is not None and len(temperatures) > 0: plot_temperature_distribution(temperatures, model_name, optimal_temp, plot_dir) plot_logitsgap_temperature_relationship(logitsgap_values, temperatures, model_name, optimal_temp, plot_dir) # 4. Compare confidence distributions across different methods if len(calibration_plots) > 1: plot_confidence_distribution(calibration_plots, model_name, plot_dir) # 5. If uncalibrated and calibrated probabilities exist, compare confidence changes if "Uncalibrated" in calibration_plots: # Create a dictionary containing only calibration methods calibrated_plots = {k: v for k, v in calibration_plots.items() if k != "Uncalibrated"} if logitsgap_values is not None: plot_confidence_change( calibration_plots["Uncalibrated"], calibrated_plots, logitsgap_values, model_name, plot_dir ) # 6. If logitsgap values exist, analyze logitsgap by correctness if logitsgap_values is not None and "Uncalibrated" in calibration_plots: plot_logitsgap_by_correctness( logitsgap_values, calibration_plots["Uncalibrated"], test_labels, model_name, plot_dir ) print("Visualization generation complete!") def evaluate_calibration_methods(val_logits, val_labels, test_logits, test_labels, val_features, test_features, args, batch_size=100, smart_epochs=200, dataset_name='imagenet', model_name='resnet50', seed_value=1, valid_size=0.2, loss_fn='CE', run_methods=None, patience=20, min_delta=0.0001, eval_metrics=None, eval_bins=None): """ Evaluate different calibration methods Args: val_logits: Logits for the calibration set val_labels: Labels for the calibration set test_logits: Logits for the test set test_labels: Labels for the test set val_features: Features for the calibration set (for ProCal methods) test_features: Features for the test set (for ProCal methods) args: Original command line arguments batch_size: Batch size for processing smart_epochs: Number of epochs for smart training dataset_name: Name of the dataset model_name: Name of the model seed_value: Random seed used valid_size: Validation set size loss_fn: Loss function used for training (only used for CIFAR models) run_methods: List of calibration methods to run, defaults to ["uncalibrated", "TS", "PTS", "CTS", "SMART"] patience: Early stopping patience (number of epochs without improvement) min_delta: Minimum change in loss to qualify as improvement for early stopping """ # Set default parameters if not provided if run_methods is None: run_methods = ["uncalibrated", "TS", "PTS", "CTS", "ETS", "SMART", "HB", "BBQ", "VS", "GC"] if eval_metrics is None: eval_metrics = DEFAULT_METRICS if eval_bins is None: eval_bins = BINS_LIST # Extract corruption type and severity from args for ImageNet-C corruption_type = getattr(args, 'corruption_type', None) if dataset_name == 'imagenet_c' else None severity = getattr(args, 'severity', None) if dataset_name == 'imagenet_c' else None # Get train_loss for CIFAR datasets train_loss = args.train_loss if dataset_name.startswith('cifar') else None # Create results directory with parameter-specific subfolder if dataset_name.startswith('imagenet'): result_dir = f"results/{dataset_name}_{model_name}_seed{seed_value}_vs{valid_size}" elif dataset_name.startswith('cifar'): # Always include train_loss for CIFAR datasets result_dir = f"results/{dataset_name}_{model_name}_{train_loss}_seed{seed_value}" else: result_dir = f"results/{dataset_name}_{model_name}_seed{seed_value}" if dataset_name == 'imagenet_c' and corruption_type is not None and severity is not None: result_dir = f"results/{dataset_name}_{corruption_type}_s{severity}_{model_name}_seed{seed_value}_vs{valid_size}" os.makedirs(result_dir, exist_ok=True) # Create plots directory with parameter-specific subfolder if dataset_name.startswith('imagenet'): plot_dir = f"plots/{dataset_name}_{model_name}_seed{seed_value}_vs{valid_size}" elif dataset_name.startswith('cifar'): # Always include train_loss for CIFAR datasets plot_dir = f"plots/{dataset_name}_{model_name}_{train_loss}_seed{seed_value}" else: plot_dir = f"plots/{dataset_name}_{model_name}_seed{seed_value}" if dataset_name == 'imagenet_c' and corruption_type is not None and severity is not None: plot_dir = f"plots/{dataset_name}_{corruption_type}_s{severity}_{model_name}_seed{seed_value}_vs{valid_size}" os.makedirs(plot_dir, exist_ok=True) # Initialize overall_results dictionary overall_results_file = os.path.join(result_dir, f"calibration_results.json") if os.path.exists(overall_results_file): # Load existing results if available with open(overall_results_file, "r") as f: overall_results = json.load(f) print(f"Loaded existing results from {overall_results_file}") else: # Create new results dictionary if not available overall_results = { 'dataset': dataset_name, 'model': model_name, 'seed': seed_value, 'valid_size': valid_size, 'overall': {} } # Convert numpy arrays to torch tensors val_logits_tensor = torch.tensor(val_logits, dtype=torch.float32) val_labels_tensor = torch.tensor(val_labels, dtype=torch.long) test_logits_tensor = torch.tensor(test_logits, dtype=torch.float32) test_labels_tensor = torch.tensor(test_labels, dtype=torch.long) # Store results for all methods results = { 'cal': [], 'ece': [], 'adaece': [], 'cece': [], 'nll': [], 'accuracy': [], 'ece_debiased': [] } # Define device device = 'cuda' if torch.cuda.is_available() else 'cpu' # Dictionary to store all calibration results calibration_plots = {} # Get loss functions for each calibration method ts_loss = getattr(args, 'ts_loss', 'CE') pts_loss = getattr(args, 'pts_loss', 'MSE') cts_loss = getattr(args, 'cts_loss', 'CE') ets_loss = getattr(args, 'ets_loss', 'mse') smart_loss = getattr(args, 'smart_loss', 'soft_ece') # Variables for visualization logitsgap_values = [] # Store logitsgap values temperatures = [] # Store temperatures generated by SMART optimal_temp = None # Store optimal temperature from TS # Prepare to load or compute logitsgap values if "SMART" in run_methods: # Get paths based on parameters paths = get_logit_paths(dataset_name, model_name, seed_value, valid_size, smart_loss, corruption_type, severity, train_loss) logitsgap_file = paths['test_logitsgap_values'] # Check if logitsgap values file exists if os.path.exists(logitsgap_file): print(f"Loading cached test logitsgap values from {logitsgap_file}") with open(logitsgap_file, "r") as f: logitsgap_dict = json.load(f) logitsgap_values = logitsgap_dict["logitsgap"] if "logitsgap" in logitsgap_dict else logitsgap_dict["hardness"] else: # If not exists, will be computed in SMART section print("logitsgap values will be computed during SMART calibration") # Check which methods already exist in the results methods_to_run = [] for method in run_methods: method_key = method.replace("-", "_").replace(" ", "_") # Determine the appropriate loss function for this method method_loss = None if method_key == 'TS': method_loss = ts_loss elif method_key == 'PTS': method_loss = pts_loss elif method_key == 'CTS': method_loss = cts_loss elif method_key == 'ETS': method_loss = ets_loss elif method_key == 'SMART': method_loss = smart_loss elif method_key == 'uncalibrated': # Uncalibrated doesn't use a loss function method_loss = 'none' elif method_key == 'LC': # Logit Clipping uses its own clipping mechanism method_loss = 'logit_clipping' elif method_key == 'GC': # Group Calibration uses group calibration mechanism method_loss = 'group_calibration' elif method_key == 'FC': # Feature Clipping uses feature clipping mechanism method_loss = 'feature_clipping' elif method_key == 'HB': # Histogram Binning uses uniform binning method_loss = 'uniform_binning' elif method_key == 'BBQ': # BBQ uses bayesian binning method_loss = 'bayesian_binning' elif method_key == 'VS': # Vector Scaling uses vector scaling method_loss = 'vector_scaling' elif method_key == 'ProCal_DR': # ProCal Density-Ratio uses density ratio method_loss = 'density_ratio' elif method_key == 'ProCal_BMS': # ProCal Bin-Mean-Shift uses bin mean shift method_loss = 'bin_mean_shift' # Check if method exists in overall results with current loss_fn method_exists = False if method_key in overall_results.get('overall', {}) and not args.overwrite: # If the method data has loss_fn info if isinstance(overall_results['overall'][method_key], dict) and 'loss_fn' in overall_results['overall'][method_key]: if overall_results['overall'][method_key]['loss_fn'] == method_loss: method_exists = True print(f"Method {method} with loss function {method_loss} already exists in results, skipping...") else: # For backward compatibility with old format results method_exists = True print(f"Method {method} already exists in results (old format), skipping...") # Special handling for SMART with different loss functions elif method_key == 'SMART' and not args.overwrite: specific_key = f'SMART_{method_loss}' if specific_key in overall_results.get('overall', {}): method_exists = True print(f"Method SMART with loss function {method_loss} already exists in results under key {specific_key}, skipping...") elif method_key == 'TS' and not args.overwrite: specific_key = f'TS_{method_loss}' if specific_key in overall_results.get('overall', {}): method_exists = True print(f"Method TS with loss function {method_loss} already exists in results under key {specific_key}, skipping...") elif method_key == 'PTS' and not args.overwrite: specific_key = f'PTS_{method_loss}' if specific_key in overall_results.get('overall', {}): method_exists = True print(f"Method PTS with loss function {method_loss} already exists in results under key {specific_key}, skipping...") elif method_key == 'CTS' and not args.overwrite: specific_key = f'CTS_{method_loss}' if specific_key in overall_results.get('overall', {}): method_exists = True print(f"Method CTS with loss function {method_loss} already exists in results under key {specific_key}, skipping...") elif method_key == 'ETS' and not args.overwrite: specific_key = f'ETS_{method_loss}' if specific_key in overall_results.get('overall', {}): method_exists = True print(f"Method ETS with loss function {method_loss} already exists in results under key {specific_key}, skipping...") elif method_key in overall_results.get('overall', {}) and args.overwrite: print(f"Method {method} already exists but overwrite=True, will run and overwrite existing results...") if not method_exists: methods_to_run.append(method) print(f"Methods to run: {methods_to_run}") # Uncalibrated if "uncalibrated" in methods_to_run: uncal_probs = F.softmax(test_logits_tensor, dim=1) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=test_logits_tensor, labels=test_labels_tensor, method_name="Uncalibrated", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Add results (using default 15 bins for backward compatibility) results['cal'].append('uncalibrated') results['ece'].append(all_metrics['ece_15']) results['accuracy'].append(all_metrics['accuracy']) results['adaece'].append(all_metrics['adaece_15']) results['cece'].append(all_metrics['cece_15']) results['nll'].append(all_metrics['nll']) results['ece_debiased'].append(all_metrics['ece_debiased_15']) # Store results store_method_results( overall_results=overall_results, method_key='uncalibrated', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='none' ) # Add to calibration plots for visualization calibration_plots['Uncalibrated'] = uncal_probs.detach().numpy() # Temperature Scaling if "TS" in methods_to_run: print("\nTraining Temperature Scaling...") # Update args for TS calibration args.cal = 'TS' if not hasattr(args, 'dataset'): args.dataset = dataset_name if not hasattr(args, 'device'): args.device = device args.n_class = dataset_num_classes.get(dataset_name, 1000) ts_loss = getattr(args, 'ts_loss', 'CE') args.loss = ts_loss print(f"Using loss function: {args.loss}") # Set seed before creating and training TS calibrator set_seed(args.random_seed) # Initialize and train the calibrator ts_calibrator = TemperatureScalingCalibrator( loss_type=args.loss, ) val_logits_device = val_logits_tensor.to(device) val_labels_device = val_labels_tensor.to(device) ts_calibrator.fit(val_logits_device, val_labels_device) # Calibrate test logits test_logits_device = test_logits_tensor.to(device) calibrated_logits = ts_calibrator.calibrate(test_logits_device, return_logits=True) ts_probs = F.softmax(calibrated_logits, dim=1).detach().cpu().numpy() # Get optimal temperature parameter optimal_temp = ts_calibrator.temperature.item() # Compute and print metrics all_metrics = compute_and_print_metrics( logits=calibrated_logits, labels=test_labels_tensor, method_name="Temperature Scaling", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) print(f"Optimal temperature: {optimal_temp:.4f}") # Save optimal temperature value for visualization optimal_temp = float(optimal_temp) # Store results store_method_results( overall_results=overall_results, method_key=f'TS_{ts_loss}', all_metrics=all_metrics, bins_list=eval_bins, loss_fn=ts_loss, additional_params={'temp': float(optimal_temp)} ) # Add to calibration plots for visualization calibration_plots['TS'] = ts_probs # Ensemble Temperature Scaling (ETS) if "ETS" in methods_to_run: print("\nTraining Ensemble Temperature Scaling...") # Get number of classes from dataset n_classes = dataset_num_classes.get(dataset_name, 1000) # Set seed before creating and training ETS calibrator set_seed(args.random_seed) # Initialize ETS calibrator ets_calibrator = ETSCalibrator(loss_type=ets_loss, n_classes=n_classes) # Fit the calibrator on validation data ets_calibrator.fit(val_logits, val_labels) # Calibrate test logits ets_probs = ets_calibrator.calibrate(test_logits) ets_probs_tensor = torch.tensor(ets_probs, dtype=torch.float32) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=ets_probs_tensor, # ETS returns probabilities labels=test_labels_tensor, method_name="Ensemble Temperature Scaling", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) print(f"Optimal temperature: {ets_calibrator.get_temperature():.4f}") print(f"Optimal weights: {ets_calibrator.get_weights()}") # Store results store_method_results( overall_results=overall_results, method_key=f'ETS_{ets_loss}', all_metrics=all_metrics, bins_list=eval_bins, loss_fn=ets_loss, additional_params={ 'temp': float(ets_calibrator.get_temperature()), 'weights': ets_calibrator.get_weights() } ) # Add to calibration plots for visualization calibration_plots['ETS'] = ets_probs # SMART if "SMART" in methods_to_run: print("\nTraining Sample logitsgap Aware Temperature Scaling...") # Use SMART loss function from argparse smart_loss = getattr(args, 'smart_loss', 'soft_ece') print("Training SMART with loss function:", smart_loss) smart = SMART(epochs=smart_epochs, dataset_name=dataset_name, model_name=model_name, seed_value=seed_value, valid_size=valid_size, loss_fn=smart_loss, patience=patience, min_delta=min_delta, corruption_type=corruption_type, severity=severity, train_loss=train_loss) # Try to load existing SMART model if not smart.load_model(): # Train new model if loading failed smart.fit(val_logits, val_labels) smart_probs = smart.calibrate(test_logits) smart_probs_tensor = torch.tensor(smart_probs, dtype=torch.float32) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=smart_probs_tensor, # SMART returns probabilities labels=test_labels_tensor, method_name="SMART", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Get logitsgap and temperature values for visualization paths = get_logit_paths(dataset_name, model_name, seed_value, valid_size, smart_loss, corruption_type, severity, train_loss) logitsgap_file = paths['test_logitsgap_values'] # Load logitsgap and temperature values for visualization if os.path.exists(logitsgap_file) and len(logitsgap_values) == 0: # If logitsgap values were not loaded before, load them now print(f"Loading cached test logitsgap values from {logitsgap_file}") with open(logitsgap_file, "r") as f: logitsgap_dict = json.load(f) logitsgap_values = logitsgap_dict["logitsgap"] if "logitsgap" in logitsgap_dict else logitsgap_dict["hardness"] # Calculate SMART-generated temperature values if len(logitsgap_values) > 0: # Use SMART model to predict temperatures logitsgap_tensor = torch.tensor(logitsgap_values, dtype=torch.float32) normalized_logitsgap = (logitsgap_tensor - smart.logitsgap_mean) / (smart.logitsgap_std + 1e-8) with torch.no_grad(): temperatures = smart.temp_model(normalized_logitsgap).detach().cpu().numpy().flatten().tolist() # Store results store_method_results( overall_results=overall_results, method_key=f'SMART_{smart_loss}', all_metrics=all_metrics, bins_list=eval_bins, loss_fn=smart_loss ) # Add to calibration plots for visualization calibration_plots['SMART'] = smart_probs # Parametric Temperature Scaling (PTS) if "PTS" in methods_to_run: print("\nTraining Parametric Temperature Scaling...") # Update args for PTS calibration args.cal = 'PTS' if not hasattr(args, 'dataset'): args.dataset = dataset_name if not hasattr(args, 'device'): args.device = device args.n_class = dataset_num_classes.get(dataset_name, 1000) pts_loss = getattr(args, 'pts_loss', 'MSE') # Initialize PTSCalibrator with overwrite flag and fixed seed pts_calibrator = PTSCalibrator( steps=10000, lr=0.00005, nlayers=2, n_nodes=5, loss_fn=pts_loss, top_k_logits=10, seed=args.random_seed # Use the same seed for consistency ).to(device) val_logits_device = val_logits_tensor.to(device) val_labels_device = val_labels_tensor.to(device) pts_calibrator.fit(val_logits_device, val_labels_device) # Calibrate test logits test_logits_device = test_logits_tensor.to(device) pts_probs = pts_calibrator.calibrate(test_logits_device).cpu().numpy() # Get calibrated logits for metric calculation calibrated_logits = pts_calibrator.calibrate(test_logits_device, return_logits=True) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=calibrated_logits, labels=test_labels_tensor, method_name="Parametric Temperature Scaling", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key=f'PTS_{pts_loss}', all_metrics=all_metrics, bins_list=eval_bins, loss_fn=pts_loss ) # Add to calibration plots for visualization calibration_plots['PTS'] = pts_probs # Class-specific Temperature Scaling (CTS) if "CTS" in methods_to_run: print("\nTraining Class-based Temperature Scaling...") # Update args for CTS calibration args.cal = 'CTS' if not hasattr(args, 'dataset'): args.dataset = dataset_name if not hasattr(args, 'device'): args.device = device args.n_class = dataset_num_classes.get(dataset_name, 1000) cts_loss = getattr(args, 'cts_loss', 'CE') args.loss = cts_loss print(f"Using loss function: {args.loss}") # Ensure labels are the correct data type for the loss function if cts_loss == 'soft_ece': # Convert labels to int64 for soft_ece loss val_labels_for_ts = val_labels_tensor.long() else: val_labels_for_ts = val_labels_tensor cts_calibrator = CTSCalibrator( n_class=args.n_class, # Number of classes n_bins=15, n_iter=5, # Number of bins for ECE computation ).to(device) # Set seed before fitting to ensure reproducibility set_seed(args.random_seed) val_logits_device = val_logits_tensor.to(device) val_labels_device = val_labels_for_ts.to(device) # Fit the calibrator on validation data cts_calibrator.fit(val_logits_device, val_labels_device, ts_loss=args.loss) # Calibrate test logits test_logits_device = test_logits_tensor.to(device) cts_probs = cts_calibrator.calibrate(test_logits_device).cpu().detach().numpy() # Get calibrated logits for metric calculation calibrated_logits = cts_calibrator.calibrate(test_logits_device, return_logits=True) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=calibrated_logits, labels=test_labels_tensor, method_name="Class-based Temperature Scaling", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key=f'CTS_{cts_loss}', all_metrics=all_metrics, bins_list=eval_bins, loss_fn=cts_loss ) # Add to calibration plots for visualization calibration_plots['CTS'] = cts_probs # Histogram Binning if "HB" in methods_to_run: print("\nTraining Histogram Binning...") set_seed(args.random_seed) # Initialize Histogram Binning calibrator hb_calibrator = HistogramBinningCalibrator(n_bins=15, strategy='uniform') # Fit the calibrator on validation data hb_calibrator.fit(val_logits_tensor, val_labels_tensor) # Apply calibration to test set hb_logits = hb_calibrator.calibrate(test_logits_tensor, return_logits=True) hb_probs = F.softmax(hb_logits, dim=1) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=hb_logits, labels=test_labels_tensor, method_name="Histogram Binning", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='HB', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='uniform_binning' ) # Add to calibration plots for visualization calibration_plots['HB'] = hb_probs.detach().numpy() # BBQ (Bayesian Binning into Quantiles) if "BBQ" in methods_to_run: print("\nTraining BBQ...") set_seed(args.random_seed) # Initialize BBQ calibrator bbq_calibrator = BBQCalibrator(score_type='max_prob', n_bins_max=20) # Fit the calibrator on validation data bbq_calibrator.fit(val_logits_tensor, val_labels_tensor) # Apply calibration to test set bbq_logits = bbq_calibrator.calibrate(test_logits_tensor, return_logits=True) bbq_probs = F.softmax(bbq_logits, dim=1) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=bbq_logits, labels=test_labels_tensor, method_name="BBQ", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='BBQ', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='bayesian_binning' ) # Add to calibration plots for visualization calibration_plots['BBQ'] = bbq_probs.detach().numpy() # Vector Scaling if "VS" in methods_to_run: print("\nTraining Vector Scaling...") set_seed(args.random_seed) # Initialize Vector Scaling calibrator vs_calibrator = VectorScalingCalibrator(loss_type='nll', bias=True) # Fit the calibrator on validation data vs_calibrator.fit(val_logits_tensor, val_labels_tensor) # Apply calibration to test set vs_logits = vs_calibrator.calibrate(test_logits_tensor, return_logits=True) vs_probs = F.softmax(vs_logits, dim=1) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=vs_logits, labels=test_labels_tensor, method_name="Vector Scaling", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='VS', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='vector_scaling' ) # Add to calibration plots for visualization calibration_plots['VS'] = vs_probs.detach().numpy() # Group Calibration if "GC" in methods_to_run: print("\nTraining Group Calibration...") set_seed(args.random_seed) # Initialize Group Calibration calibrator (matching original paper: K=2, U=20, λ=0.1) gc_calibrator = GroupCalibrationCalibrator( num_groups=2, num_partitions=20, weight_decay=0.1 ) # Fit the calibrator on validation data gc_calibrator.fit(val_logits_tensor, val_labels_tensor) # Apply calibration to test set gc_logits = gc_calibrator.calibrate(test_logits_tensor, return_logits=True) gc_probs = F.softmax(gc_logits, dim=1) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=gc_logits, labels=test_labels_tensor, method_name="Group Calibration", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='GC', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='group_calibration' ) # Add to calibration plots for visualization calibration_plots['GC'] = gc_probs.detach().numpy() # ProCal Density-Ratio Calibration if "ProCal_DR" in methods_to_run: print("\nTraining ProCal Density-Ratio Calibration...") set_seed(args.random_seed) # Initialize ProCal Density-Ratio calibrator procal_dr_calibrator = ProCalDensityRatioCalibrator( k_neighbors=10, bandwidth='normal_reference', kernel='KDEMultivariate', distance_measure='L2', normalize_features=True ) # Convert features to tensors val_features_tensor = torch.tensor(val_features, dtype=torch.float32).to(device) test_features_tensor = torch.tensor(test_features, dtype=torch.float32).to(device) # Fit the calibrator on validation data with features procal_dr_calibrator.fit(val_logits_tensor, val_labels_tensor, val_features_tensor) # Apply calibration to test set with features procal_dr_probs = procal_dr_calibrator.calibrate(test_logits_tensor, test_features_tensor) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=procal_dr_probs, labels=test_labels_tensor, method_name="ProCal Density-Ratio", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='ProCal_DR', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='density_ratio' ) # Add to calibration plots for visualization calibration_plots['ProCal_DR'] = procal_dr_probs.detach().numpy() # ProCal Bin-Mean-Shift Calibration if "ProCal_BMS" in methods_to_run: print("\nTraining ProCal Bin-Mean-Shift Calibration...") set_seed(args.random_seed) from sklearn.isotonic import IsotonicRegression # Initialize ProCal Bin-Mean-Shift calibrator procal_bms_calibrator = ProCalBinMeanShiftCalibrator( base_calibrator_class=IsotonicRegression, k_neighbors=10, proximity_bins=10, bin_strategy='quantile', distance_measure='L2', normalize_features=True, out_of_bounds='clip' # Parameter for IsotonicRegression ) # Fit the calibrator on validation data with features procal_bms_calibrator.fit(val_logits_tensor, val_labels_tensor, val_features_tensor) # Apply calibration to test set with features procal_bms_probs = procal_bms_calibrator.calibrate(test_logits_tensor, test_features_tensor) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=procal_bms_probs, labels=test_labels_tensor, method_name="ProCal Bin-Mean-Shift", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='ProCal_BMS', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='bin_mean_shift' ) # Add to calibration plots for visualization calibration_plots['ProCal_BMS'] = procal_bms_probs.detach().numpy() # Feature Clipping Calibration if "FC" in methods_to_run: print("\nTraining Feature Clipping Calibration...") set_seed(args.random_seed) # Create the same model that was used to extract features model = create_model(args, model_name, dataset_name, device) model.eval() # Get the classifier function - all our models have a classifier method classifier_fn = model.classifier # Initialize Feature Clipping calibrator fc_calibrator = FeatureClippingCalibrator(cross_validate='ece') # Convert features to tensors val_features_tensor = torch.tensor(val_features, dtype=torch.float32).to(device) test_features_tensor = torch.tensor(test_features, dtype=torch.float32).to(device) # Set optimal clipping parameter using validation data optimal_clip = fc_calibrator.set_feature_clip( val_features_tensor, val_logits_tensor, val_labels_tensor, classifier_fn ) print(f"Optimal clipping parameter: {optimal_clip:.4f}") # Apply feature clipping to test features and get calibrated logits clipped_test_features = fc_calibrator.feature_clipping(test_features_tensor, optimal_clip) fc_logits = classifier_fn(clipped_test_features) fc_probs = F.softmax(fc_logits, dim=1) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=fc_logits, labels=test_labels_tensor, method_name="Feature Clipping", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='FC', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='feature_clipping' ) # Add to calibration plots for visualization calibration_plots['FC'] = fc_probs.detach().cpu().numpy() # Logit Clipping Calibration if "LC" in methods_to_run: print("\nTraining Logit Clipping Calibration...") set_seed(args.random_seed) # Initialize Logit Clipping calibrator lc_calibrator = LogitClippingCalibrator() # Fit the calibrator on validation data using ECE cross-validation optimal_clip = lc_calibrator.fit(val_logits_tensor, val_labels_tensor, cross_validate='ece') print(f"Optimal clipping parameter: {optimal_clip:.4f}") # Apply calibration to test set lc_probs = lc_calibrator.calibrate(test_logits_tensor, return_logits=False) lc_logits = lc_calibrator.calibrate(test_logits_tensor, return_logits=True) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=lc_logits, labels=test_labels_tensor, method_name="Logit Clipping", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results store_method_results( overall_results=overall_results, method_key='LC', all_metrics=all_metrics, bins_list=eval_bins, loss_fn='logit_clipping', additional_params={'clip_value': float(optimal_clip)} ) # Add to calibration plots for visualization calibration_plots['LC'] = lc_probs.detach().cpu().numpy() # Density Aware Calibration (DAC) if "DAC" in methods_to_run: print("\nTraining Density Aware Calibration...") # Get the base calibration method from args dac_base_method = getattr(args, 'dac_base_method', 'TS') print(f"Using DAC with base method: {dac_base_method}") set_seed(args.random_seed) try: # Create base calibrator based on specified method (TS, PTS, or SMART supported) base_calibrator = None if dac_base_method == 'TS': ts_loss = getattr(args, 'ts_loss', 'CE') base_calibrator = TemperatureScalingCalibrator(loss_type=ts_loss) elif dac_base_method == 'PTS': pts_loss = getattr(args, 'pts_loss', 'MSE') base_calibrator = PTSCalibrator( steps=10000, lr=0.00005, nlayers=2, n_nodes=5, loss_fn=pts_loss, top_k_logits=10, seed=args.random_seed ).to(device) elif dac_base_method == 'SMART': smart_loss = getattr(args, 'smart_loss', 'smooth_soft_ece') print(f"Creating SMART base calibrator with loss function: {smart_loss}") # Extract corruption parameters if available corruption_type = getattr(args, 'corruption_type', None) if dataset_name == 'imagenet_c' else None severity = getattr(args, 'severity', None) if dataset_name == 'imagenet_c' else None train_loss = getattr(args, 'train_loss', None) base_calibrator = SMART( epochs=smart_epochs, dataset_name=dataset_name, model_name=model_name, seed_value=args.random_seed, valid_size=valid_size, loss_fn=smart_loss, patience=patience, min_delta=min_delta, corruption_type=corruption_type, severity=severity, train_loss=train_loss ) else: raise ValueError(f"Unsupported DAC base method: {dac_base_method}. Supported methods: TS, PTS, SMART") # Determine loss type for DAC optimization based on base calibrator if dac_base_method == 'TS': dac_loss_type = 'ce' elif dac_base_method == 'PTS': dac_loss_type = 'mse' elif dac_base_method == 'SMART': # For SMART, use MSE as it works well with its optimization dac_loss_type = 'mse' else: dac_loss_type = 'ce' # default dac_calibrator = DensityAwareCalibrator( ood_values_num=1, # TODO: Should be 6 for multi-layer (requires model changes) loss_type=dac_loss_type, # Match base calibrator knn_k=10, # Paper specification for ImageNet (was 50) avg_top_k=False, # default gpu=False, # use CPU to avoid compatibility issues base_calibrator=base_calibrator ) # Convert features to tensors if they're numpy arrays val_features_tensor = torch.tensor(val_features, dtype=torch.float32) if isinstance(val_features, np.ndarray) else val_features test_features_tensor = torch.tensor(test_features, dtype=torch.float32) if isinstance(test_features, np.ndarray) else test_features # CRITICAL FIX: Extract actual training features for KNN density estimation # The original code incorrectly used validation features as training features, # which fundamentally breaks the density estimation (each sample becomes its own nearest neighbor) print("Extracting training features for DAC KNN density estimation...") # Create model and train_loader for feature extraction dac_model = create_model(args, model_name, dataset_name, device) dac_model.eval() train_loader = create_train_loader_for_dac(args, dataset_name) # Extract reference features for KNN density estimation # For ImageNet-C: using original uncorrupted val set (50k images) # Extract 10k samples (~20% of val set, or ~0.8% of full training set) max_samples = 10000 if dataset_name.startswith('imagenet') else 5000 train_features_tensor = extract_train_features_for_dac( dac_model, train_loader, device, max_samples=max_samples ) print(f"Extracted {train_features_tensor.shape[0]} reference features for DAC KNN") # Clean up del dac_model torch.cuda.empty_cache() # Fit the DAC calibrator dac_result = dac_calibrator.fit( val_logits=val_logits_tensor, val_labels=val_labels_tensor, val_features=val_features_tensor, train_features=train_features_tensor # Use actual training features ) print(f"DAC fitting completed. Result: {dac_result}") # Apply calibration to test set dac_probs = dac_calibrator.calibrate( test_logits=test_logits_tensor, test_features=test_features_tensor, return_logits=False ) dac_logits = dac_calibrator.calibrate( test_logits=test_logits_tensor, test_features=test_features_tensor, return_logits=True ) # Compute and print metrics all_metrics = compute_and_print_metrics( logits=dac_logits, labels=test_labels_tensor, method_name=f"DAC + {dac_base_method}", bins_list=eval_bins, device=device, enabled_metrics=eval_metrics ) # Store results # Convert numpy arrays to lists for JSON serialization if isinstance(dac_result, dict): dac_weights = dac_result['dac_weights'] if hasattr(dac_weights, 'tolist'): dac_weights = dac_weights.tolist() base_result = dac_result.get('base_result', None) else: dac_weights = dac_result.tolist() if hasattr(dac_result, 'tolist') else dac_result base_result = None store_method_results( overall_results=overall_results, method_key=f'DAC_{dac_base_method}', all_metrics=all_metrics, bins_list=eval_bins, loss_fn=f'dac_{dac_base_method.lower()}', additional_params={ 'dac_weights': dac_weights, 'base_result': base_result, 'base_method': dac_base_method } ) # Add to calibration plots for visualization calibration_plots[f'DAC_{dac_base_method}'] = dac_probs.detach().cpu().numpy() except ImportError as e: print(f"Warning: Could not use DAC due to missing dependencies: {e}") print("Please install faiss-cpu or faiss-gpu to use Density Aware Calibration") except Exception as e: print(f"Error in DAC calibration: {e}") import traceback traceback.print_exc() # Save the updated results with open(overall_results_file, "w") as f: json.dump(overall_results, f, indent=4) print(f"Saved updated results to {overall_results_file}") # Generate visualizations generate_visualizations(test_logits, test_labels, calibration_plots, logitsgap_values, temperatures, optimal_temp, methods_to_run, model_name, plot_dir) return overall_results