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