SMART/plotting/visualization.py

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import os

def compute_ece(probs, labels, n_bins=15):
    """
    Compute ECE (Expected Calibration Error)
    
    Args:
        probs: numpy array of shape [n_samples, n_classes] with probabilities
        labels: numpy array of shape [n_samples] with ground truth labels
        n_bins: number of bins for confidence histogram
        
    Returns:
        Expected Calibration Error
    """
    bin_boundaries = np.linspace(0, 1, n_bins + 1)
    bin_lowers = bin_boundaries[:-1]
    bin_uppers = bin_boundaries[1:]
    
    confidences = np.max(probs, axis=1)
    predictions = np.argmax(probs, axis=1)
    accuracies = (predictions == labels)
    
    ece = 0.0
    for bin_lower, bin_upper in zip(bin_lowers, bin_uppers):
        in_bin = np.logical_and(confidences > bin_lower, confidences <= bin_upper)
        prop_in_bin = np.mean(in_bin)
        if prop_in_bin > 0:
            accuracy_in_bin = np.mean(accuracies[in_bin])
            avg_confidence_in_bin = np.mean(confidences[in_bin])
            ece += np.abs(avg_confidence_in_bin - accuracy_in_bin) * prop_in_bin
    
    return ece

def plot_enhanced_calibration_curve(probs, labels, method_name, plot_dir=None):
    """
    Plot enhanced reliability diagram with confidence histograms
    
    Args:
        probs: numpy array of shape [n_samples, n_classes] with probabilities
        labels: numpy array of shape [n_samples] with ground truth labels
        method_name: string name of the calibration method for the title
        plot_dir: directory to save the plot, if None, saves to "plots/"
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    n_bins = 15
    
    # Get predicted confidence and check if prediction is correct
    confidences = np.max(probs, axis=1)
    predictions = np.argmax(probs, axis=1)
    accuracies = (predictions == labels)
    
    # Create figure with confidence histogram
    fig, ax1 = plt.subplots(figsize=(10, 8))
    
    # Plot calibration curve
    bin_boundaries = np.linspace(0, 1, n_bins + 1)
    bin_lowers = bin_boundaries[:-1]
    bin_uppers = bin_boundaries[1:]
    bin_centers = (bin_lowers + bin_uppers) / 2
    
    true_probs = []
    mean_confidences = []
    sample_counts = []
    
    for bin_lower, bin_upper in zip(bin_lowers, bin_uppers):
        in_bin = np.logical_and(confidences > bin_lower, confidences <= bin_upper)
        bin_count = np.sum(in_bin)
        sample_counts.append(bin_count)
        
        if bin_count > 0:
            true_prob = np.mean(accuracies[in_bin])
            mean_conf = np.mean(confidences[in_bin])
            true_probs.append(true_prob)
            mean_confidences.append(mean_conf)
        else:
            true_probs.append(0)
            mean_confidences.append(bin_centers[len(mean_confidences)])
    
    # Plot perfect calibration line
    ax1.plot([0, 1], [0, 1], 'k--', label='Perfectly calibrated')
    # Plot calibration curve
    ax1.plot(mean_confidences, true_probs, 's-', label='Calibration curve')
    
    # Add calibration metrics
    ece = compute_ece(probs, labels)
    ax1.set_xlabel('Mean predicted probability', fontsize=24)
    ax1.set_ylabel('Fraction of positives', fontsize=24)
    ax1.set_xlim([0, 1])
    ax1.set_ylim([0, 1])
    ax1.legend(loc='lower right', fontsize=24)
    ax1.grid(True)
    ax1.tick_params(axis='both', which='major', labelsize=24)
    
    # Create confidence histogram on the same plot
    ax2 = ax1.twinx()
    
    # Plot separate histograms for correct and incorrect predictions
    correct_confidences = confidences[accuracies]
    incorrect_confidences = confidences[~accuracies]
    
    ax2.hist([correct_confidences, incorrect_confidences], bins=20,
             color=['green', 'red'], alpha=0.3, label=['Correct', 'Incorrect'],
             stacked=True)

    ax2.set_ylabel('Count', fontsize=24)
    ax2.legend(loc='upper right', fontsize=24)
    ax2.tick_params(axis='both', which='major', labelsize=24)
    
    # Save the plot
    plt.tight_layout()
    save_path = os.path.join(plot_dir, f'calibration_{method_name.replace(" ", "_")}.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()
    
    return ece

def plot_logitsgap_analysis(test_logitsgap, model_name, plot_dir=None):
    """
    Plot logitsgap distribution with CDF
    
    Args:
        test_logitsgap: array of logitsgap values
        model_name: name of the model
        plot_dir: directory to save the plot
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    # Plot detailed logitsgap distribution as a bar chart
    plt.figure(figsize=(14, 8))
    
    # Create bins
    num_bins = 20
    logitsgap_hist, logitsgap_bin_edges = np.histogram(test_logitsgap, bins=num_bins, range=(0, 10))
    logitsgap_bin_centers = 0.5 * (logitsgap_bin_edges[1:] + logitsgap_bin_edges[:-1])
    
    # Create bin labels
    logitsgap_bin_labels = [f"{logitsgap_bin_edges[i]:.1f}-{logitsgap_bin_edges[i+1]:.1f}" 
                          for i in range(len(logitsgap_bin_edges)-1)]
    
    plt.bar(logitsgap_bin_centers, logitsgap_hist,
            width=(logitsgap_bin_edges[1] - logitsgap_bin_edges[0]) * 0.8,
            alpha=0.7, label=f'{model_name}')
    plt.xlabel('Logit Margin', fontsize=24)
    plt.ylabel('Count', fontsize=24)
    plt.grid(alpha=0.3)
    plt.xticks(logitsgap_bin_centers, logitsgap_bin_labels, rotation=45, fontsize=24)
    plt.yticks(fontsize=24)
    plt.legend(fontsize=24)
    plt.tight_layout()
    save_path = os.path.join(plot_dir, 'detailed_logitsgap_distribution.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()
    
    return {
        'bin_labels': logitsgap_bin_labels,
        'bin_centers': logitsgap_bin_centers.tolist(),
        'bin_edges': logitsgap_bin_edges.tolist(),
        'counts': logitsgap_hist.tolist(),
        'percentage': (logitsgap_hist / len(test_logitsgap) * 100).tolist()
    }

def plot_temperature_distribution(temps, model_name, optimal_temp=None, plot_dir=None):
    """
    Plot temperature distribution
    
    Args:
        temps: array of temperature values
        model_name: name of the model
        optimal_temp: optimal temperature from TS (optional)
        plot_dir: directory to save the plot
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    # Calculate range
    temp_min = float(np.min(temps))
    temp_max = float(np.max(temps))
    temp_range = (max(0.1, temp_min - 0.1), temp_max + 0.1)
    
    # Create histogram
    temp_hist, temp_bin_edges = np.histogram(temps, bins=20, range=temp_range)
    temp_bin_centers = 0.5 * (temp_bin_edges[1:] + temp_bin_edges[:-1])
    
    # Create bin labels
    temp_bin_labels = [f"{temp_bin_edges[i]:.2f}-{temp_bin_edges[i+1]:.2f}" 
                      for i in range(len(temp_bin_edges)-1)]
    
    # Plot temperature distribution
    plt.figure(figsize=(14, 8))
    plt.bar(temp_bin_centers, temp_hist,
            width=(temp_bin_edges[1] - temp_bin_edges[0]) * 0.8,
            alpha=0.7, label=f'{model_name}')
    plt.xlabel('Temperature', fontsize=24)
    plt.ylabel('Count', fontsize=24)
    plt.grid(alpha=0.3)
    plt.xticks(temp_bin_centers, temp_bin_labels, rotation=45, fontsize=24)
    plt.yticks(fontsize=24)
    
    if optimal_temp is not None:
        plt.axvline(x=optimal_temp, color='r', linestyle='--',
                   label=f'TS temp: {optimal_temp:.4f}')

    plt.legend(fontsize=24)
    plt.tight_layout()
    save_path = os.path.join(plot_dir, 'detailed_temperature_distribution.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()
    
    return {
        'bin_labels': temp_bin_labels,
        'bin_centers': temp_bin_centers.tolist(),
        'bin_edges': temp_bin_edges.tolist(),
        'counts': temp_hist.tolist(),
        'percentage': (temp_hist / len(temps) * 100).tolist()
    }

def plot_logitsgap_temperature_relationship(test_logitsgap, temps, model_name, optimal_temp=None, plot_dir=None):
    """
    Plot relationship between logitsgap and temperature
    
    Args:
        test_logitsgap: array of logitsgap values
        temps: array of temperature values
        model_name: name of the model
        optimal_temp: optimal temperature from TS (optional)
        plot_dir: directory to save the plot
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    # Calculate correlation and regression
    logitsgap_temp_corr, logitsgap_temp_pvalue = stats.pearsonr(test_logitsgap, temps)
    slope, intercept, r_value, p_value, std_err = stats.linregress(test_logitsgap, temps)
    
    # Plot density heatmap
    plt.figure(figsize=(14, 10))
    plt.hexbin(test_logitsgap, temps, gridsize=30, cmap='viridis', mincnt=1)
    cbar = plt.colorbar(label='Count')
    cbar.ax.tick_params(labelsize=24)
    cbar.set_label('Count', fontsize=24)
    
    # Add regression line
    plt.plot(np.array([min(test_logitsgap), max(test_logitsgap)]),
            intercept + slope * np.array([min(test_logitsgap), max(test_logitsgap)]),
            'r-', linewidth=3, label=f'Regression line (r={r_value:.2f})')

    plt.xlabel('Logit Margin', fontsize=24)
    plt.ylabel('Temperature', fontsize=24)

    if optimal_temp is not None:
        plt.axhline(y=optimal_temp, color='r', linestyle='--', linewidth=2,
                   label=f'TS temp={optimal_temp:.2f}')

    plt.legend(fontsize=24)
    plt.grid(alpha=0.3)
    plt.xticks(fontsize=24)
    plt.yticks(fontsize=24)
    plt.tight_layout()
    save_path = os.path.join(plot_dir, 'logitsgap_temperature_density_map.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()
    
    # Plot regular scatter plot with CDF
    plt.figure(figsize=(12, 10))
    
    # logitsgap distribution
    plt.subplot(2, 1, 1)
    counts, bins, _ = plt.hist(test_logitsgap, bins=30, alpha=0.7, label=f'{model_name}')
    plt.xlabel('Logit Margin', fontsize=24)
    plt.ylabel('Count', fontsize=24)
    plt.legend(fontsize=24)
    plt.xticks(fontsize=24)
    plt.yticks(fontsize=24)
    
    # Add Quantiles
    quantiles = [0.25, 0.5, 0.75]
    quantile_values = np.quantile(test_logitsgap, quantiles)
    for i, q in enumerate(quantiles):
        plt.axvline(x=quantile_values[i], color='r', linestyle='--',
                  alpha=0.5, label=f'{int(q*100)}th percentile' if i == 0 else "")

    # Plot CDF
    ax2 = plt.gca().twinx()
    cdf = np.cumsum(counts) / np.sum(counts)
    bin_centers = 0.5 * (bins[1:] + bins[:-1])
    ax2.plot(bin_centers, cdf, 'g-', label='CDF')
    ax2.set_ylabel('Cumulative Probability', fontsize=24)
    ax2.set_ylim([0, 1])
    ax2.tick_params(axis='both', which='major', labelsize=24)
    plt.legend(loc='upper left', fontsize=24)
    
    # logitsgap vs temperature
    plt.subplot(2, 1, 2)
    plt.scatter(test_logitsgap, temps, alpha=0.3, label=f'{model_name} samples')
    
    # Add regression line
    plt.plot(np.array([min(test_logitsgap), max(test_logitsgap)]),
            intercept + slope * np.array([min(test_logitsgap), max(test_logitsgap)]),
            'r', label=f'Regression line (r={r_value:.2f})')

    plt.xlabel('Logit Margin', fontsize=24)
    plt.ylabel('Temperature', fontsize=24)

    if optimal_temp is not None:
        plt.axhline(y=optimal_temp, color='r', linestyle='-', label=f'TS temp={optimal_temp:.2f}')

    plt.legend(fontsize=24)
    plt.xticks(fontsize=24)
    plt.yticks(fontsize=24)
    plt.tight_layout()
    save_path = os.path.join(plot_dir, 'logitsgap_temperature_mapping.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()
    
    return {
        'logitsgap_temperature_correlation': float(logitsgap_temp_corr),
        'logitsgap_temperature_pvalue': float(logitsgap_temp_pvalue),
        'regression': {
            'slope': float(slope),
            'intercept': float(intercept),
            'r_value': float(r_value),
            'p_value': float(p_value),
            'std_err': float(std_err)
        }
    }

def plot_confidence_distribution(probs_dict, model_name, plot_dir=None):
    """
    Plot confidence distribution for different methods
    
    Args:
        probs_dict: dictionary mapping method names to probability arrays
        model_name: name of the model
        plot_dir: directory to save the plot
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    plt.figure(figsize=(10, 8))
    hist_data = []
    labels = []
    
    for method, probs in probs_dict.items():
        hist_data.append(np.max(probs, axis=1))
        labels.append(method)

    plt.hist(hist_data, bins=20, alpha=0.7, label=labels)
    plt.xlabel('Confidence', fontsize=24)
    plt.ylabel('Count', fontsize=24)
    plt.legend(fontsize=24)
    plt.grid(alpha=0.3)
    plt.xticks(fontsize=24)
    plt.yticks(fontsize=24)
    save_path = os.path.join(plot_dir, 'confidence_distribution.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()

def plot_confidence_change(uncal_probs, calibrated_probs_dict, test_logitsgap, model_name, plot_dir=None, 
                          color_by_prediction_groups=False, labels=None, top_k=2):
    """
    Plot confidence change vs logitsgap for different methods
    
    Args:
        uncal_probs: uncalibrated probabilities
        calibrated_probs_dict: dictionary mapping method names to calibrated probability arrays
        test_logitsgap: array of logitsgap values
        model_name: name of the model
        plot_dir: directory to save the plot
        color_by_prediction_groups: whether to color points by prediction correctness and logits gap groups
        labels: true labels (required if color_by_prediction_groups=True)
        top_k: number of top predictions to consider (required if color_by_prediction_groups=True)
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    # Validation for color grouping
    if color_by_prediction_groups and (labels is None):
        raise ValueError("labels must be provided when color_by_prediction_groups=True")
    
    plt.figure(figsize=(12, 10))
    
    num_methods = len(calibrated_probs_dict)
    method_idx = 0
    
    for method, probs in calibrated_probs_dict.items():
        conf_change = np.max(probs, axis=1) - np.max(uncal_probs, axis=1)
        
        plt.subplot(num_methods, 1, method_idx + 1)
        
        if not color_by_prediction_groups:
            # Original coloring - single color for all points
            plt.scatter(test_logitsgap, conf_change, alpha=0.3, label=method)
        else:
            # New coloring scheme based on prediction correctness and logits gap
            # Convert logitsgap to array and handle different formats
            test_logitsgap_array = np.array(test_logitsgap)
            
            # If logitsgap is a list of lists (gap vectors), take the first element of each
            if test_logitsgap_array.ndim > 1:
                # For gap vectors, take the first gap (largest gap)
                test_logitsgap_array = test_logitsgap_array[:, 0]
            
            print(f"Processing method: {method}")
            print(f"Logitsgap array shape: {test_logitsgap_array.shape}")
            print(f"Logitsgap sample values: {test_logitsgap_array[:5]}")
            print(f"Confidence change shape: {conf_change.shape}")
            print(f"Labels shape: {labels.shape}")
            print(f"Top_k: {top_k}")
            
            # Get predictions
            predictions = np.argmax(uncal_probs, axis=1)
            
            # Sort predictions by confidence to get top-k
            sorted_indices = np.argsort(uncal_probs, axis=1)[:, ::-1]  # Sort in descending order
            
            # Determine prediction correctness
            correct_predictions = (predictions == labels)
            
            # Group by logits gap size (3 groups)
            n_samples = len(test_logitsgap_array)
            n_groups = 3
            group_size = n_samples // n_groups
            
            # Sort indices by logits gap for grouping
            gap_sorted_indices = np.argsort(test_logitsgap_array)
            
            # Define color schemes
            # For correct predictions: use blue shades (light blue for small gap, dark blue for large gap)
            correct_small_gap_color = '#ADD8E6'  # Light blue
            correct_large_gap_color = '#000080'  # Navy blue
            
            # For incorrect predictions in top k: use green shades
            incorrect_in_topk_small_gap_color = '#90EE90'  # Light green
            incorrect_in_topk_large_gap_color = '#006400'  # Dark green
            
            # For incorrect predictions not in top k: use red shades
            incorrect_not_in_topk_small_gap_color = '#FFB6C1'  # Light pink
            incorrect_not_in_topk_large_gap_color = '#8B0000'  # Dark red
            
            # Create mapping from sample index to gap group
            gap_groups = {}
            for rank_idx in range(n_samples):
                sample_idx = int(gap_sorted_indices[rank_idx])  # Convert to int to ensure hashable
                if rank_idx < group_size:
                    gap_groups[sample_idx] = 1  # Small gap
                elif rank_idx >= n_samples - group_size:
                    gap_groups[sample_idx] = 3  # Large gap
                else:
                    gap_groups[sample_idx] = 2  # Middle group (will be skipped)
            
            # Collect points by category for batch plotting
            categories = {
                'Correct (Small Gap)': {'x': [], 'y': [], 'color': correct_small_gap_color},
                'Correct (Large Gap)': {'x': [], 'y': [], 'color': correct_large_gap_color},
                'Incorrect (In Top-k, Small Gap)': {'x': [], 'y': [], 'color': incorrect_in_topk_small_gap_color},
                'Incorrect (In Top-k, Large Gap)': {'x': [], 'y': [], 'color': incorrect_in_topk_large_gap_color},
                'Incorrect (Not in Top-k, Small Gap)': {'x': [], 'y': [], 'color': incorrect_not_in_topk_small_gap_color},
                'Incorrect (Not in Top-k, Large Gap)': {'x': [], 'y': [], 'color': incorrect_not_in_topk_large_gap_color}
            }
            
            # Categorize points
            for sample_idx in range(n_samples):
                gap_value = test_logitsgap_array[sample_idx]
                conf_change_value = conf_change[sample_idx]
                
                # Get gap group for this sample
                gap_group = gap_groups.get(sample_idx, 2)
                if gap_group == 2:
                    continue  # Skip middle group as requested
                
                if correct_predictions[sample_idx]:
                    # Correct prediction - use blue shades
                    if gap_group == 1:  # Small gap
                        category = 'Correct (Small Gap)'
                    else:  # Large gap (group 3)
                        category = 'Correct (Large Gap)'
                else:
                    # Incorrect prediction - check if true label is in top k
                    top_k_predictions = sorted_indices[sample_idx, :top_k]
                    true_label_in_topk = labels[sample_idx] in top_k_predictions
                    
                    if true_label_in_topk:
                        # True label in top k - use green shades
                        if gap_group == 1:  # Small gap
                            category = 'Incorrect (In Top-k, Small Gap)'
                        else:  # Large gap (group 3)
                            category = 'Incorrect (In Top-k, Large Gap)'
                    else:
                        # True label not in top k - use red shades
                        if gap_group == 1:  # Small gap
                            category = 'Incorrect (Not in Top-k, Small Gap)'
                        else:  # Large gap (group 3)
                            category = 'Incorrect (Not in Top-k, Large Gap)'
                
                categories[category]['x'].append(gap_value)
                categories[category]['y'].append(conf_change_value)
            
            # Plot each category
            for category, data in categories.items():
                if len(data['x']) > 0:  # Only plot if there are points in this category
                    print(f"Plotting {len(data['x'])} points for category: {category}")
                    plt.scatter(data['x'], data['y'], alpha=0.6, color=data['color'], s=10, label=category)
                else:
                    print(f"No points found for category: {category}")
            
            print(f"Total samples: {n_samples}, Group size: {group_size}")
            print(f"Gap groups distribution: {list(gap_groups.values()).count(1)} small, {list(gap_groups.values()).count(2)} middle, {list(gap_groups.values()).count(3)} large")


        plt.axhline(y=0, color='k', linestyle='--')
        plt.xlabel('Logit Margin', fontsize=24)
        plt.ylabel('Conf Change', fontsize=24)
        if color_by_prediction_groups:
            plt.legend(fontsize=18, bbox_to_anchor=(1.05, 1), loc='upper left')
        else:
            plt.legend(fontsize=24)
        plt.grid(alpha=0.3)
        plt.xticks(fontsize=24)
        plt.yticks(fontsize=24)
        plt.title(f'{method}', fontsize=26)
        
        method_idx += 1
    
    plt.tight_layout()
    save_path = os.path.join(plot_dir, 'logitsgap_vs_confidence_change.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()

def plot_logitsgap_by_correctness(test_logitsgap, probs, labels, model_name, plot_dir=None):
    """
    Plot logitsgap distribution separated by prediction correctness
    
    Args:
        test_logitsgap: array of logitsgap values
        probs: predicted probabilities
        labels: true labels
        model_name: name of the model
        plot_dir: directory to save the plot
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    correct = (np.argmax(probs, axis=1) == labels)
    
    plt.figure(figsize=(10, 8))
    plt.hist([np.array(test_logitsgap)[correct], np.array(test_logitsgap)[~correct]],
            bins=20, alpha=0.7, label=['Correct', 'Incorrect'])
    plt.xlabel('Logit Margin', fontsize=24)
    plt.ylabel('Count', fontsize=24)
    plt.legend(fontsize=24)
    plt.grid(alpha=0.3)
    plt.xticks(fontsize=24)
    plt.yticks(fontsize=24)
    save_path = os.path.join(plot_dir, 'logitsgap_by_correctness.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()

def plot_performance_by_logitsgap(ece_by_group, acc_by_group, group_names, plot_dir=None):
    """
    Plot calibration and accuracy performance by logitsgap level
    
    Args:
        ece_by_group: dictionary mapping method names to ECE values by group
        acc_by_group: dictionary mapping method names to accuracy values by group
        group_names: names of logitsgap groups
        plot_dir: directory to save the plot
    """
    if plot_dir is None:
        plot_dir = "plots"
    os.makedirs(plot_dir, exist_ok=True)
    
    plt.figure(figsize=(12, 8))
    x = np.arange(len(group_names))
    width = 0.25
    
    # ECE subplot
    plt.subplot(2, 1, 1)
    
    offset = -width
    for method, ece_values in ece_by_group.items():
        plt.bar(x + offset, ece_values, width, label=method)
        offset += width

    plt.xlabel('Logit Margin Group', fontsize=24)
    plt.ylabel('ECE (lower is better)', fontsize=24)
    plt.xticks(x, group_names, fontsize=24)
    plt.yticks(fontsize=24)
    plt.legend(fontsize=24)
    plt.grid(axis='y', linestyle='--', alpha=0.7)
    
    # Accuracy subplot
    plt.subplot(2, 1, 2)
    
    offset = -width
    for method, acc_values in acc_by_group.items():
        plt.bar(x + offset, acc_values, width, label=method)
        offset += width

    plt.xlabel('Logit Margin Group', fontsize=24)
    plt.ylabel('Accuracy (higher is better)', fontsize=24)
    plt.xticks(x, group_names, fontsize=24)
    plt.yticks(fontsize=24)
    plt.legend(fontsize=24)
    plt.grid(axis='y', linestyle='--', alpha=0.7)
    
    plt.tight_layout()
    save_path = os.path.join(plot_dir, 'performance_by_logitsgap.pdf')
    plt.savefig(save_path, format='pdf', dpi=1000, bbox_inches='tight')
    plt.close()