import sys import os import numpy as np import torch import torch.nn as nn import torch.nn.functional as F import matplotlib.pyplot as plt from tqdm import tqdm import json import time # Add the parent directory to the path to import from PureLogits 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) # Import necessary components from the calibrator from calibrator.Component.metrics import ( BrierLoss, CrossEntropyLoss, MSELoss, SoftECE, ECE ) # Set random seed for reproducibility def set_seed(seed): np.random.seed(seed) torch.manual_seed(seed) if torch.cuda.is_available(): torch.cuda.manual_seed(seed) torch.cuda.manual_seed_all(seed) torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False # Load logits and labels from cache directory def load_data(cache_dir): val_logits = np.load(os.path.join(cache_dir, "val_logits.npy")) val_labels = np.load(os.path.join(cache_dir, "val_labels.npy")) test_logits = np.load(os.path.join(cache_dir, "test_logits.npy")) test_labels = np.load(os.path.join(cache_dir, "test_labels.npy")) print(f"Loaded data: val_logits shape: {val_logits.shape}, val_labels shape: {val_labels.shape}") print(f"Loaded data: test_logits shape: {test_logits.shape}, test_labels shape: {test_labels.shape}") return val_logits, val_labels, test_logits, test_labels # Compute hardness as the gap between top logit and runner-up def compute_hardness(logits): logits_tensor = torch.tensor(logits, dtype=torch.float32) sorted_logits, _ = torch.sort(logits_tensor, descending=True) logit_gap = (sorted_logits[0] - sorted_logits[1]).item() return logit_gap # Custom ECE wrapper to ensure it returns a tensor that can be backpropagated class ECEWrapper(nn.Module): def __init__(self, n_bins=15): super(ECEWrapper, self).__init__() self.ece = ECE(n_bins=n_bins) def forward(self, logits, labels): # ECE returns a scalar value, we need to wrap it in a tensor with requires_grad=True ece_value = self.ece(logits, labels) # Check if the result is already a tensor with grad if isinstance(ece_value, torch.Tensor) and ece_value.requires_grad: return ece_value # Otherwise, create a tensor with requires_grad=True if isinstance(ece_value, torch.Tensor): return ece_value.clone().detach().requires_grad_(True) else: return torch.tensor(ece_value, requires_grad=True, device=logits.device) # Custom Brier Loss implementation that ensures it's different from MSE class CustomBrierLoss(nn.Module): def __init__(self): super(CustomBrierLoss, self).__init__() def forward(self, logits, labels): # Get predicted probabilities outputs = F.softmax(logits, dim=1) # Convert labels to one-hot one_hot = torch.zeros(labels.size(0), outputs.size(1), device=labels.device) one_hot.scatter_(1, labels.unsqueeze(1), 1) # Compute Brier loss brier_score = torch.mean(torch.sum((outputs - one_hot) ** 2, dim=1)) # Explicitly scale by 0.5 to differentiate from MSE return brier_score * 0.5 # Experiment 1: Compare gradient stability of different calibration objectives def experiment_1_gradient_stability(test_logits, test_labels, cache_dir, output_dir="results"): print("\nExperiment 1: Comparing Gradient Stability of Different Calibration Objectives") # Create output directory os.makedirs(output_dir, exist_ok=True) # Convert data to PyTorch tensors logits_tensor = torch.tensor(test_logits, dtype=torch.float32) labels_tensor = torch.tensor(test_labels, dtype=torch.long) # Initialize different loss functions soft_ece = SoftECE(n_bins=15) traditional_ece = ECEWrapper(n_bins=15) # Use wrapper for ECE brier_score = BrierLoss() cross_entropy = CrossEntropyLoss() mse_loss = MSELoss() # Temperature parameter with gradient tracking temperature = nn.Parameter(torch.ones(1)) # Sample a subset of data for visualization (to avoid clutter) num_samples = 1000 indices = np.random.choice(len(test_logits), num_samples, replace=False) # Confidence bins for analysis confidence_bins = np.linspace(0.5, 1.0, 10) bin_width = confidence_bins[1] - confidence_bins[0] # Store gradients for each loss function across confidence levels results = { "SoftECE": {"grads": [], "conf_bins": []}, "ECE": {"grads": [], "conf_bins": []}, "Brier": {"grads": [], "conf_bins": []}, "CrossEntropy": {"grads": [], "conf_bins": []}, "MSE": {"grads": [], "conf_bins": []} } # Calculate gradients for different temperature values temp_values = [0.5, 0.8, 1.0, 1.2, 1.5, 2.0] for temp_val in temp_values: print(f"\nAnalyzing gradients at temperature = {temp_val}") # Set temperature to current value with torch.no_grad(): temperature.fill_(temp_val) # Process samples in batches to avoid memory issues batch_size = 100 num_batches = (num_samples + batch_size - 1) // batch_size for batch_idx in tqdm(range(num_batches)): start_idx = batch_idx * batch_size end_idx = min((batch_idx + 1) * batch_size, num_samples) batch_indices = indices[start_idx:end_idx] batch_logits = logits_tensor[batch_indices] batch_labels = labels_tensor[batch_indices] # Apply temperature scaling scaled_logits = batch_logits / temperature probs = F.softmax(scaled_logits, dim=1) # Calculate confidence (max probability) confidences = torch.max(probs, dim=1)[0].detach().numpy() # Calculate gradients for each loss function for loss_name, loss_fn in [ ("SoftECE", soft_ece), ("ECE", traditional_ece), ("Brier", brier_score), ("CrossEntropy", cross_entropy), ("MSE", mse_loss) ]: temperature.grad = None if loss_name == "SoftECE": loss = loss_fn(scaled_logits, batch_labels) elif loss_name == "ECE": loss = loss_fn(scaled_logits, batch_labels) elif loss_name == "Brier": loss = loss_fn(scaled_logits, batch_labels) elif loss_name == "CrossEntropy": loss = loss_fn(scaled_logits, batch_labels) elif loss_name == "MSE": loss = loss_fn(scaled_logits, batch_labels) loss.backward(retain_graph=True) # Store gradient magnitude for each sample if temperature.grad is not None: grad_magnitude = temperature.grad.item() # Store gradients by confidence bin for i, conf in enumerate(confidences): bin_idx = np.digitize(conf, confidence_bins) - 1 if 0 <= bin_idx < len(confidence_bins): results[loss_name]["grads"].append(grad_magnitude) results[loss_name]["conf_bins"].append(confidence_bins[bin_idx]) # Plot gradient magnitudes across confidence levels plt.figure(figsize=(10, 6)) for loss_name in ["SoftECE", "ECE", "Brier", "CrossEntropy", "MSE"]: # Group gradients by confidence bin binned_grads = {} for grad, bin_val in zip(results[loss_name]["grads"], results[loss_name]["conf_bins"]): if bin_val not in binned_grads: binned_grads[bin_val] = [] binned_grads[bin_val].append(grad) # Calculate mean and std of gradients for each bin bin_centers = [] mean_grads = [] std_grads = [] for bin_val in sorted(binned_grads.keys()): if binned_grads[bin_val]: # Ensure there are gradients for this bin bin_centers.append(bin_val) mean_grads.append(np.mean(np.abs(binned_grads[bin_val]))) std_grads.append(np.std(np.abs(binned_grads[bin_val]))) # Plot mean gradient magnitude with error bars plt.errorbar(bin_centers, mean_grads, yerr=std_grads, label=loss_name, marker='o', capsize=4) plt.xlabel('Confidence Level') plt.ylabel('Gradient Magnitude') plt.title('Gradient Stability Across Confidence Levels') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'gradient_stability.png'), dpi=300) plt.close() # Save results with open(os.path.join(output_dir, 'gradient_stability_results.json'), 'w') as f: # Convert numpy arrays to lists for JSON serialization serializable_results = {} for loss_name, data in results.items(): serializable_results[loss_name] = { "grads": [float(g) for g in data["grads"]], "conf_bins": [float(c) for c in data["conf_bins"]] } json.dump(serializable_results, f, indent=2) print(f"Gradient stability analysis complete. Results saved to {output_dir}") # Experiment 2: Gradient information content analysis def experiment_2_gradient_information(test_logits, test_labels, cache_dir, output_dir="results"): print("\nExperiment 2: Analyzing Gradient Information Content of Different Calibration Objectives") # Create output directory os.makedirs(output_dir, exist_ok=True) # Convert data to PyTorch tensors logits_tensor = torch.tensor(test_logits, dtype=torch.float32) labels_tensor = torch.tensor(test_labels, dtype=torch.long) # Sample a subset of data num_samples = 2000 indices = np.random.choice(len(test_logits), num_samples, replace=False) # Initialize different loss functions soft_ece = SoftECE(n_bins=15, sigma=0.05) traditional_ece = ECEWrapper(n_bins=15) brier_score = BrierLoss() cross_entropy = CrossEntropyLoss() mse_loss = MSELoss() # Create synthetic miscalibration by distorting temperatures # We'll create 5 different scenarios ranging from underconfident to overconfident temp_scenarios = [0.5, 0.8, 1.0, 1.2, 2.0] # Store gradient direction consistency and correlation with calibration error results = { "temp_scenario": [], "ece_values": [], "gradient_consistency": {}, "gradient_correlation": {}, "gradient_entropy": {} } for loss_name in ["SoftECE", "ECE", "Brier", "CrossEntropy", "MSE"]: results["gradient_consistency"][loss_name] = [] results["gradient_correlation"][loss_name] = [] results["gradient_entropy"][loss_name] = [] # Create confidence bins for analysis confidence_bins = np.linspace(0.1, 1.0, 10) for temperature_value in temp_scenarios: print(f"\nAnalyzing scenario with temperature = {temperature_value}") # Set up temperature parameter for this scenario temperature = nn.Parameter(torch.ones(1) * temperature_value) # Generate scaled logits for the whole dataset to calculate overall ECE with torch.no_grad(): overall_scaled_logits = logits_tensor / temperature overall_probs = F.softmax(overall_scaled_logits, dim=1) ece_metric = ECE(n_bins=15) ece_value = ece_metric(overall_scaled_logits, labels_tensor).item() results["temp_scenario"].append(temperature_value) results["ece_values"].append(ece_value) print(f"Overall ECE for temperature {temperature_value}: {ece_value:.4f}") # For each loss function, analyze gradient properties for loss_name, loss_fn in [ ("SoftECE", soft_ece), ("ECE", traditional_ece), ("Brier", brier_score), ("CrossEntropy", cross_entropy), ("MSE", mse_loss) ]: print(f"Analyzing gradients for {loss_name}") # Calculate gradients for each sample in batches batch_size = 100 num_batches = (num_samples + batch_size - 1) // batch_size # Store all gradients and corresponding confidences all_grads = [] all_confidences = [] all_is_correct = [] for batch_idx in tqdm(range(num_batches)): start_idx = batch_idx * batch_size end_idx = min((batch_idx + 1) * batch_size, num_samples) batch_indices = indices[start_idx:end_idx] batch_logits = logits_tensor[batch_indices] batch_labels = labels_tensor[batch_indices] # Calculate gradients per sample for i in range(len(batch_logits)): sample_logits = batch_logits[i:i+1] sample_label = batch_labels[i:i+1] # Reset parameter to temperature_value for each sample temperature = nn.Parameter(torch.ones(1) * temperature_value) # Apply temperature scaling scaled_logits = sample_logits / temperature probs = F.softmax(scaled_logits, dim=1) # Check if prediction is correct pred = torch.argmax(probs, dim=1) is_correct = (pred == sample_label).float().item() # Calculate confidence confidence = torch.max(probs).item() # Calculate loss and gradient temperature.grad = None try: loss = loss_fn(scaled_logits, sample_label) loss.backward() # Only store if gradient was successfully calculated if temperature.grad is not None: all_grads.append(temperature.grad.item()) all_confidences.append(confidence) all_is_correct.append(is_correct) except Exception as e: # Skip samples that cause errors in gradient calculation print(f" Skipping sample due to error: {e}") continue # Skip further analysis if we don't have enough gradient data if len(all_grads) < 10: print(f" Not enough gradient data for {loss_name}, skipping analysis") continue # Calculate gradient consistency per confidence bin # (correlation between gradient direction and correctness) bin_grad_consistency = [] bin_grad_entropy = [] for i in range(len(confidence_bins) - 1): bin_start = confidence_bins[i] bin_end = confidence_bins[i+1] # Find samples in this bin bin_indices = [] for j in range(len(all_confidences)): if bin_start <= all_confidences[j] < bin_end: bin_indices.append(j) if len(bin_indices) > 5: # Only consider bins with enough samples bin_grads = [all_grads[j] for j in bin_indices] bin_correct = [all_is_correct[j] for j in bin_indices] # Calculate consistency: avg sign of gradient * (conf - accuracy) bin_conf = np.mean([all_confidences[j] for j in bin_indices]) bin_acc = np.mean(bin_correct) calibration_error = bin_conf - bin_acc # Compute correlation between gradient and calibration error # A well-behaved gradient should be negative when confidence > accuracy # and positive when confidence < accuracy grad_signs = np.sign(bin_grads) ce_sign = np.sign(calibration_error) correct_direction = -1 * ce_sign # Gradient should point in opposite direction of error consistency = np.mean(grad_signs == correct_direction) bin_grad_consistency.append(consistency) # Calculate entropy of gradient distribution in this bin # Normalize gradients for comparison if len(bin_grads) > 0 and np.std(bin_grads) > 0: norm_grads = (bin_grads - np.mean(bin_grads)) / np.std(bin_grads) # Use histogram to estimate entropy hist, _ = np.histogram(norm_grads, bins=10, density=True) hist = hist[hist > 0] # Avoid log(0) entropy = -np.sum(hist * np.log(hist)) bin_grad_entropy.append(entropy) # Store results if bin_grad_consistency: avg_consistency = np.mean(bin_grad_consistency) results["gradient_consistency"][loss_name].append(avg_consistency) print(f" {loss_name} gradient consistency: {avg_consistency:.4f}") if bin_grad_entropy: avg_entropy = np.mean(bin_grad_entropy) results["gradient_entropy"][loss_name].append(avg_entropy) print(f" {loss_name} gradient entropy: {avg_entropy:.4f}") # Calculate correlation between gradient and calibration error # For overall dataset if len(all_grads) > 0: accuracies = np.array(all_is_correct) confidences = np.array(all_confidences) grads = np.array(all_grads) # Ensure we have valid data if len(grads) > 0 and not np.all(np.isnan(grads)): cal_errors = confidences - accuracies # Correlation should be negative (gradient points opposite to error) correlation = np.corrcoef(cal_errors, -grads)[0, 1] if not np.isnan(correlation): results["gradient_correlation"][loss_name].append(correlation) print(f" {loss_name} gradient-error correlation: {correlation:.4f}") # Plot results # 1. Plot gradient consistency across different calibration scenarios plt.figure(figsize=(10, 6)) for loss_name in ["SoftECE", "ECE", "Brier", "CrossEntropy", "MSE"]: if loss_name in results["gradient_consistency"] and len(results["gradient_consistency"][loss_name]) > 0: plt.plot(results["temp_scenario"], results["gradient_consistency"][loss_name], marker='o', label=loss_name) plt.xlabel('Temperature (Lower = More Overconfident)') plt.ylabel('Gradient Direction Consistency') plt.title('Gradient Consistency Across Calibration Scenarios') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'gradient_consistency.png'), dpi=300) plt.close() # 2. Plot gradient-error correlation plt.figure(figsize=(10, 6)) for loss_name in ["SoftECE", "ECE", "Brier", "CrossEntropy", "MSE"]: if loss_name in results["gradient_correlation"] and len(results["gradient_correlation"][loss_name]) > 0: plt.plot(results["temp_scenario"], results["gradient_correlation"][loss_name], marker='o', label=loss_name) plt.xlabel('Temperature (Lower = More Overconfident)') plt.ylabel('Correlation between Gradient and Calibration Error') plt.title('Gradient-Error Correlation Across Calibration Scenarios') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'gradient_correlation.png'), dpi=300) plt.close() # 3. Plot gradient entropy (information content) plt.figure(figsize=(10, 6)) for loss_name in ["SoftECE", "ECE", "Brier", "CrossEntropy", "MSE"]: if loss_name in results["gradient_entropy"] and len(results["gradient_entropy"][loss_name]) > 0: plt.plot(results["temp_scenario"], results["gradient_entropy"][loss_name], marker='o', label=loss_name) plt.xlabel('Temperature (Lower = More Overconfident)') plt.ylabel('Gradient Distribution Entropy') plt.title('Gradient Information Content Across Calibration Scenarios') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'gradient_entropy.png'), dpi=300) plt.close() # Save results with open(os.path.join(output_dir, 'gradient_information_results.json'), 'w') as f: # Ensure all data is serializable serializable_results = { "temp_scenario": list(results["temp_scenario"]), "ece_values": list(results["ece_values"]), "gradient_consistency": {k: list(v) for k, v in results["gradient_consistency"].items()}, "gradient_correlation": {k: list(v) for k, v in results["gradient_correlation"].items()}, "gradient_entropy": {k: list(v) for k, v in results["gradient_entropy"].items()} } json.dump(serializable_results, f, indent=2) print(f"Gradient information analysis complete. Results saved to {output_dir}") # Experiment 3: Sample efficiency and overfitting resistance analysis def experiment_3_sample_efficiency(val_logits, val_labels, test_logits, test_labels, cache_dir, output_dir="results"): print("\nExperiment 3: Analyzing Sample Efficiency and Overfitting Resistance") # Create output directory os.makedirs(output_dir, exist_ok=True) # Convert data to PyTorch 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) # Define different validation set sizes to test val_set_sizes = [10, 20, 30, 40,50, 100, 150] val_set_sizes = [min(size, len(val_logits)) for size in val_set_sizes] # Define loss functions to compare loss_functions = [ ("SoftECE", lambda: SoftECE(n_bins=15, sigma=0.05)), ("Brier", lambda: CustomBrierLoss()), ("CrossEntropy", lambda: CrossEntropyLoss()), ("MSE", lambda: MSELoss()) ] # Number of training steps to monitor max_steps = 100 step_interval = 5 # Record metrics every n steps # Store results results = { "val_set_sizes": val_set_sizes, "training_curves": {size: {} for size in val_set_sizes}, "final_metrics": {size: {} for size in val_set_sizes}, } # Train on different validation set sizes for val_size in val_set_sizes: print(f"\nTraining with validation set size: {val_size}") # Sample a subset of validation data indices = np.random.choice(len(val_logits), val_size, replace=False) subset_logits = val_logits_tensor[indices] subset_labels = val_labels_tensor[indices] # For each loss function for loss_name, loss_fn_creator in loss_functions: print(f" Training with {loss_name}") # Initialize results storage for this scenario if loss_name not in results["training_curves"][val_size]: results["training_curves"][val_size][loss_name] = { "steps": [], "train_loss": [], "train_ece": [], "test_ece": [], "test_acc": [] } if loss_name not in results["final_metrics"][val_size]: results["final_metrics"][val_size][loss_name] = {} # Initialize temperature and optimizer temperature = nn.Parameter(torch.ones(1)) optimizer = torch.optim.Adam([temperature], lr=0.01) # Create loss function loss_fn = loss_fn_creator() # Training loop with tracking for step in range(max_steps): optimizer.zero_grad() # Apply temperature scaling scaled_logits = subset_logits / temperature # Calculate loss loss = loss_fn(scaled_logits, subset_labels) # Backpropagation loss.backward() optimizer.step() # Record metrics at specified intervals if step % step_interval == 0 or step == max_steps - 1: with torch.no_grad(): # Calculate training metrics train_ece = ECE(n_bins=15)(scaled_logits, subset_labels).item() # Calculate test metrics test_scaled_logits = test_logits_tensor / temperature test_probs = F.softmax(test_scaled_logits, dim=1) test_ece = ECE(n_bins=15)(test_scaled_logits, test_labels_tensor).item() test_acc = (torch.argmax(test_probs, dim=1) == test_labels_tensor).float().mean().item() # Store metrics results["training_curves"][val_size][loss_name]["steps"].append(step) results["training_curves"][val_size][loss_name]["train_loss"].append(loss.item()) results["training_curves"][val_size][loss_name]["train_ece"].append(train_ece) results["training_curves"][val_size][loss_name]["test_ece"].append(test_ece) results["training_curves"][val_size][loss_name]["test_acc"].append(test_acc) # Store final metrics results["final_metrics"][val_size][loss_name] = { "temperature": temperature.item(), "train_ece": train_ece, "test_ece": test_ece, "test_acc": test_acc, "train_test_ece_gap": abs(train_ece - test_ece) # Measure of overfitting } print(f" Final temperature: {temperature.item():.4f}, Test ECE: {test_ece:.4f}") # Plot results # 1. Plot final test ECE vs validation set size plt.figure(figsize=(10, 6)) print("\nFinal Test ECE values for plotting:") for loss_name, _ in loss_functions: test_eces = [results["final_metrics"][size][loss_name]["test_ece"] for size in val_set_sizes] print(f" {loss_name}: {test_eces}") line, = plt.plot(val_set_sizes, test_eces, marker='o', linewidth=2, markersize=8) plt.annotate(loss_name, (val_set_sizes[-1], test_eces[-1]), xytext=(5, 0), textcoords='offset points', va='center') plt.xlabel('Validation Set Size') plt.ylabel('Test ECE') plt.title('Sample Efficiency: Test ECE vs. Validation Set Size') plt.legend([loss_name for loss_name, _ in loss_functions]) plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'sample_efficiency_ece.png'), dpi=300) plt.close() # 2. Plot train-test ECE gap vs validation set size (measure of overfitting) plt.figure(figsize=(10, 6)) print("\nTrain-Test ECE Gap values for plotting:") for loss_name, _ in loss_functions: gaps = [results["final_metrics"][size][loss_name]["train_test_ece_gap"] for size in val_set_sizes] print(f" {loss_name}: {gaps}") line, = plt.plot(val_set_sizes, gaps, marker='o', linewidth=2, markersize=8) plt.annotate(loss_name, (val_set_sizes[-1], gaps[-1]), xytext=(5, 0), textcoords='offset points', va='center') plt.xlabel('Validation Set Size') plt.ylabel('|Train ECE - Test ECE|') plt.title('Overfitting Resistance: Train-Test Gap vs. Validation Set Size') plt.legend([loss_name for loss_name, _ in loss_functions]) plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'overfitting_resistance.png'), dpi=300) plt.close() # 3. Plot training curves for different loss functions on smallest dataset smallest_size = val_set_sizes[0] plt.figure(figsize=(12, 8)) for loss_name, _ in loss_functions: steps = results["training_curves"][smallest_size][loss_name]["steps"] test_eces = results["training_curves"][smallest_size][loss_name]["test_ece"] plt.plot(steps, test_eces, marker='.', label=f"{loss_name}") plt.xlabel('Training Step') plt.ylabel('Test ECE') plt.title(f'Training Stability with Small Dataset (n={smallest_size})') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, f'training_stability_{smallest_size}.png'), dpi=300) plt.close() # 4. Plot training curves for SoftECE across different dataset sizes plt.figure(figsize=(12, 8)) for val_size in val_set_sizes: steps = results["training_curves"][val_size]["SoftECE"]["steps"] test_eces = results["training_curves"][val_size]["SoftECE"]["test_ece"] plt.plot(steps, test_eces, marker='.', label=f"n={val_size}") plt.xlabel('Training Step') plt.ylabel('Test ECE') plt.title('SoftECE Training Curves Across Dataset Sizes') plt.legend() plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'softece_across_sizes.png'), dpi=300) plt.close() # Save results with open(os.path.join(output_dir, 'sample_efficiency_results.json'), 'w') as f: # Ensure all data is serializable serializable_results = { "val_set_sizes": results["val_set_sizes"], "training_curves": {}, "final_metrics": {} } # Convert training curves for size in results["training_curves"]: serializable_results["training_curves"][str(size)] = {} for loss_name in results["training_curves"][size]: serializable_results["training_curves"][str(size)][loss_name] = { k: [float(v_i) for v_i in v] for k, v in results["training_curves"][size][loss_name].items() } # Convert final metrics for size in results["final_metrics"]: serializable_results["final_metrics"][str(size)] = {} for loss_name in results["final_metrics"][size]: serializable_results["final_metrics"][str(size)][loss_name] = { k: float(v) for k, v in results["final_metrics"][size][loss_name].items() } json.dump(serializable_results, f, indent=2) print(f"Sample efficiency analysis complete. Results saved to {output_dir}") # Experiment 4: Bias-variance tradeoff visualization def experiment_4_bias_variance_tradeoff(val_logits, val_labels, test_logits, test_labels, cache_dir, output_dir="results"): print("\nExperiment 4: Visualizing Bias-Variance Tradeoff") # Create output directory os.makedirs(output_dir, exist_ok=True) # Convert data to PyTorch 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) # Define loss functions to compare loss_functions = [ ("SoftECE", lambda: SoftECE(n_bins=15, sigma=0.05)), ("ECE", lambda: ECEWrapper(n_bins=15)), ("Brier", lambda: CustomBrierLoss()), ("CrossEntropy", lambda: CrossEntropyLoss()), ("MSE", lambda: MSELoss()) ] # Bootstrap parameters n_bootstraps = 20 # Number of bootstrap samples bootstrap_size = min(500, len(val_logits)) # Size of each bootstrap sample # Store results results = { "bootstrap_metrics": {loss_name: { "temperatures": [], "test_eces": [], "calibrated_confidences": [] } for loss_name, _ in loss_functions}, "aggregated_metrics": {loss_name: {} for loss_name, _ in loss_functions} } # Create bootstrap samples print(f"Creating {n_bootstraps} bootstrap samples of size {bootstrap_size}") bootstrap_indices = [] for i in range(n_bootstraps): # Sample with replacement indices = np.random.choice(len(val_logits), bootstrap_size, replace=True) bootstrap_indices.append(indices) # Train on each bootstrap sample for bootstrap_idx, indices in enumerate(bootstrap_indices): print(f"\nTraining on bootstrap sample {bootstrap_idx+1}/{n_bootstraps}") # Get bootstrap sample bootstrap_logits = val_logits_tensor[indices] bootstrap_labels = val_labels_tensor[indices] # Train each loss function on this bootstrap sample for loss_name, loss_fn_creator in loss_functions: # Initialize temperature and optimizer temperature = nn.Parameter(torch.ones(1)) optimizer = torch.optim.Adam([temperature], lr=0.01) # Create loss function loss_fn = loss_fn_creator() # Train for a fixed number of epochs epochs = 100 for epoch in range(epochs): optimizer.zero_grad() # Apply temperature scaling scaled_logits = bootstrap_logits / temperature # Calculate loss loss = loss_fn(scaled_logits, bootstrap_labels) # Backpropagation loss.backward() optimizer.step() # Evaluate on test set with torch.no_grad(): # Apply learned temperature scaled_test_logits = test_logits_tensor / temperature test_probs = F.softmax(scaled_test_logits, dim=1) # Calculate metrics test_ece = ECE(n_bins=15)(scaled_test_logits, test_labels_tensor).item() # Store max confidences from a random subset for visualization subset_size = min(1000, len(test_logits)) subset_indices = np.random.choice(len(test_logits), subset_size, replace=False) subset_confs = torch.max(test_probs[subset_indices], dim=1)[0].cpu().numpy() # Store results for this bootstrap run results["bootstrap_metrics"][loss_name]["temperatures"].append(temperature.item()) results["bootstrap_metrics"][loss_name]["test_eces"].append(test_ece) results["bootstrap_metrics"][loss_name]["calibrated_confidences"].append(subset_confs) print(f" {loss_name}: Temperature = {temperature.item():.4f}, Test ECE = {test_ece:.4f}") # Calculate aggregated metrics for loss_name, _ in loss_functions: temps = results["bootstrap_metrics"][loss_name]["temperatures"] eces = results["bootstrap_metrics"][loss_name]["test_eces"] # Calculate statistics results["aggregated_metrics"][loss_name] = { "temperature_mean": np.mean(temps), "temperature_std": np.std(temps), "temperature_cv": np.std(temps) / np.mean(temps) if np.mean(temps) > 0 else 0, # Coefficient of variation "ece_mean": np.mean(eces), "ece_std": np.std(eces), "ece_cv": np.std(eces) / np.mean(eces) if np.mean(eces) > 0 else 0 } # Prepare plots # 1. Box plots of learned temperatures plt.figure(figsize=(10, 6)) temp_data = [results["bootstrap_metrics"][loss_name]["temperatures"] for loss_name, _ in loss_functions] plt.boxplot(temp_data, labels=[loss_name for loss_name, _ in loss_functions]) plt.ylabel('Temperature Value') plt.title('Distribution of Learned Temperatures Across Bootstrap Samples') plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'temperature_distribution.png'), dpi=300) plt.close() # 2. Box plots of test ECEs plt.figure(figsize=(10, 6)) ece_data = [results["bootstrap_metrics"][loss_name]["test_eces"] for loss_name, _ in loss_functions] plt.boxplot(ece_data, labels=[loss_name for loss_name, _ in loss_functions]) plt.ylabel('Test ECE') plt.title('Distribution of Test ECE Across Bootstrap Samples') plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'ece_distribution.png'), dpi=300) plt.close() # 3. Scatter plot of temperature variance vs ECE mean plt.figure(figsize=(10, 6)) temp_vars = [results["aggregated_metrics"][loss_name]["temperature_cv"] for loss_name, _ in loss_functions] ece_means = [results["aggregated_metrics"][loss_name]["ece_mean"] for loss_name, _ in loss_functions] plt.scatter(temp_vars, ece_means, s=100) # Add labels to points for i, (loss_name, _) in enumerate(loss_functions): plt.annotate(loss_name, (temp_vars[i], ece_means[i]), textcoords="offset points", xytext=(0,10), ha='center') plt.xlabel('Temperature Coefficient of Variation') plt.ylabel('Mean Test ECE') plt.title('Bias-Variance Tradeoff: Parameter Stability vs. Calibration Performance') plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'bias_variance_tradeoff.png'), dpi=300) plt.close() # 4. Histograms of calibrated confidences for each method # We'll use the last bootstrap sample for visualization plt.figure(figsize=(15, 10)) for i, (loss_name, _) in enumerate(loss_functions): plt.subplot(2, 3, i+1) confidences = results["bootstrap_metrics"][loss_name]["calibrated_confidences"][-1] plt.hist(confidences, bins=20, alpha=0.7) plt.title(f'{loss_name} Calibrated Confidences') plt.xlabel('Confidence') plt.ylabel('Count') plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'calibrated_confidence_distribution.png'), dpi=300) plt.close() # 5. Violin plots of ECE distribution plt.figure(figsize=(12, 6)) # Create violin plot plt.violinplot(ece_data, showmeans=True, showmedians=True) # Add labels plt.xticks(range(1, len(loss_functions) + 1), [loss_name for loss_name, _ in loss_functions]) plt.ylabel('Test ECE') plt.title('Density Distribution of Test ECE Across Bootstrap Samples') plt.grid(True, alpha=0.3) plt.tight_layout() plt.savefig(os.path.join(output_dir, 'ece_density_distribution.png'), dpi=300) plt.close() # Save results with open(os.path.join(output_dir, 'bias_variance_results.json'), 'w') as f: # Ensure all data is serializable serializable_results = { "bootstrap_metrics": {}, "aggregated_metrics": {} } # Convert bootstrap metrics for loss_name in results["bootstrap_metrics"]: serializable_results["bootstrap_metrics"][loss_name] = { "temperatures": [float(t) for t in results["bootstrap_metrics"][loss_name]["temperatures"]], "test_eces": [float(e) for e in results["bootstrap_metrics"][loss_name]["test_eces"]], # Don't save all confidences as it's too much data "temperature_mean": float(np.mean(results["bootstrap_metrics"][loss_name]["temperatures"])), "temperature_std": float(np.std(results["bootstrap_metrics"][loss_name]["temperatures"])), "ece_mean": float(np.mean(results["bootstrap_metrics"][loss_name]["test_eces"])), "ece_std": float(np.std(results["bootstrap_metrics"][loss_name]["test_eces"])) } # Convert aggregated metrics for loss_name in results["aggregated_metrics"]: serializable_results["aggregated_metrics"][loss_name] = { k: float(v) for k, v in results["aggregated_metrics"][loss_name].items() } json.dump(serializable_results, f, indent=2) print(f"Bias-variance tradeoff analysis complete. Results saved to {output_dir}") def main(): # Set random seed set_seed(42) # Define cache directory containing logits and labels cache_dir = "/hdd/haolan/shats/PureLogits/cache/imagenet_vit_b_16_seed1_vs0.2" # cache_dir = "/hdd/haolan/shats/PureLogits/cache/cifar100_resnet50_cross_entropy_seed1" # cache_dir = "/hdd/haolan/shats/PureLogits/cache/imagenet_resnet50_seed1_vs0.2" # cache_dir = "/hdd/haolan/shats/PureLogits/cache/cifar10_resnet50_cross_entropy_seed1" # Load data val_logits, val_labels, test_logits, test_labels = load_data(cache_dir) # Create output directory output_dir = "experiment_results/softece_validation" os.makedirs(output_dir, exist_ok=True) # Run experiments # experiment_1_gradient_stability(test_logits, test_labels, cache_dir, output_dir) # experiment_2_gradient_information(test_logits, test_labels, cache_dir, output_dir) experiment_3_sample_efficiency(val_logits, val_labels, test_logits, test_labels, cache_dir, output_dir) # experiment_4_bias_variance_tradeoff(val_logits, val_labels, test_logits, test_labels, cache_dir, output_dir) if __name__ == "__main__": start_time = time.time() main() elapsed_time = time.time() - start_time print(f"Experiments completed in {elapsed_time/60:.2f} minutes")