SMART/KdeTraining/kde_hyperparameter_search.py

#!/usr/bin/env python3
"""
KDE Hyperparameter Search Script

This script performs systematic hyperparameter search for KDE regularization weight (λ).
Based on the principle: Loss = CrossEntropy + λ × KDE_ECE

Search range: λ ∈ [0.001, 0.2] as suggested by the literature.
Selection method: Validation set performance (KDE ECE + Standard ECE)
"""

import os
import sys
import json
import subprocess
from datetime import datetime
import numpy as np

current_dir = os.path.dirname(os.path.abspath(__file__))

def run_kde_experiment_with_validation(dataset, arch, kde_weight, epochs=50, seed=1):
    """
    Run KDE experiment with validation-based hyperparameter selection.
    Uses shorter epochs for hyperparameter search to save time.
    """
    cmd = [
        'python', 'train_kde_regularized.py',
        '--mode', 'single',
        '--dataset', dataset,
        '--arch', arch,
        '--epochs', str(epochs),
        '--seed', str(seed),
        '--kde_weight', str(kde_weight),
        '--batch_size', '1024' if dataset.startswith('cifar') else '256'
    ]
    
    print(f"Testing λ = {kde_weight}")
    print(f"Command: {' '.join(cmd)}")
    
    try:
        result = subprocess.run(cmd, cwd=current_dir, capture_output=True, text=True, timeout=3600)
        
        if result.returncode == 0:
            # Parse results from stdout
            output_lines = result.stdout.split('\n')
            final_kde_ece = None
            final_std_ece = None
            final_acc = None
            
            for line in output_lines:
                if 'Final KDE ECE:' in line:
                    try:
                        final_kde_ece = float(line.split('Final KDE ECE:')[1].strip())
                    except:
                        pass
                elif 'Final Standard ECE:' in line:
                    try:
                        final_std_ece = float(line.split('Final Standard ECE:')[1].strip())
                    except:
                        pass
                elif 'Final test accuracy:' in line:
                    try:
                        final_acc = float(line.split('Final test accuracy:')[1].strip().rstrip('%'))
                    except:
                        pass
            
            return True, {
                'kde_ece': final_kde_ece,
                'std_ece': final_std_ece,
                'accuracy': final_acc,
                'kde_weight': kde_weight
            }
        else:
            print(f"Training failed: {result.stderr}")
            return False, {'error': result.stderr}
            
    except Exception as e:
        print(f"Exception: {e}")
        return False, {'error': str(e)}

def kde_hyperparameter_search(dataset='cifar10', arch='resnet50', search_epochs=50):
    """
    Systematic hyperparameter search for KDE regularization weight.
    
    Search strategy:
    1. Coarse search in [0.001, 0.2] with log scale
    2. Fine search around the best coarse result
    3. Final validation with best parameters
    """
    
    print("="*60)
    print("KDE Hyperparameter Search")
    print("="*60)
    print(f"Dataset: {dataset}, Architecture: {arch}")
    print(f"Search epochs per experiment: {search_epochs}")
    print(f"Optimization target: CrossEntropy + λ × KDE_ECE")
    print(f"Search range: λ ∈ [0.001, 0.2]")
    
    # Phase 1: Coarse search (log scale)
    print("\n" + "="*40)
    print("Phase 1: Coarse Search")
    print("="*40)
    
    coarse_lambdas = [0.0, 0.001, 0.003, 0.01, 0.03, 0.1, 0.2]
    coarse_results = []
    
    for kde_weight in coarse_lambdas:
        print(f"\n--- Coarse search: λ = {kde_weight} ---")
        success, result = run_kde_experiment_with_validation(dataset, arch, kde_weight, search_epochs)
        
        if success:
            result['phase'] = 'coarse'
            coarse_results.append(result)
            print(f"✓ λ={kde_weight}: Acc={result['accuracy']:.2f}%, KDE_ECE={result['kde_ece']:.4f}, Std_ECE={result['std_ece']:.4f}")
        else:
            print(f"✗ λ={kde_weight}: Failed")
    
    if not coarse_results:
        print("No successful coarse results. Aborting search.")
        return None
    
    # Analyze coarse results
    print(f"\n--- Coarse Search Results ({len(coarse_results)} successful) ---")
    for result in coarse_results:
        score = result['kde_ece'] + result['std_ece']  # Combined calibration score
        print(f"λ={result['kde_weight']}: Combined_ECE={score:.4f} (KDE={result['kde_ece']:.4f} + Std={result['std_ece']:.4f}), Acc={result['accuracy']:.2f}%")
    
    # Find best λ from coarse search (minimize combined ECE)
    best_coarse = min(coarse_results, key=lambda x: x['kde_ece'] + x['std_ece'])
    best_lambda_coarse = best_coarse['kde_weight']
    
    print(f"\nBest coarse λ: {best_lambda_coarse} (Combined ECE: {best_coarse['kde_ece'] + best_coarse['std_ece']:.4f})")
    
    # Phase 2: Fine search around best coarse result
    print("\n" + "="*40)
    print("Phase 2: Fine Search")
    print("="*40)
    
    if best_lambda_coarse == 0.0:
        fine_lambdas = [0.0005, 0.001, 0.002]
    elif best_lambda_coarse == 0.2:
        fine_lambdas = [0.15, 0.2, 0.25]
    else:
        # Search around the best coarse value
        fine_lambdas = [
            best_lambda_coarse * 0.5,
            best_lambda_coarse * 0.7,
            best_lambda_coarse,
            best_lambda_coarse * 1.3,
            best_lambda_coarse * 1.5
        ]
        # Ensure within valid range
        fine_lambdas = [max(0.001, min(0.2, lam)) for lam in fine_lambdas]
        fine_lambdas = list(set(fine_lambdas))  # Remove duplicates
    
    fine_results = []
    
    for kde_weight in fine_lambdas:
        print(f"\n--- Fine search: λ = {kde_weight:.4f} ---")
        success, result = run_kde_experiment_with_validation(dataset, arch, kde_weight, search_epochs)
        
        if success:
            result['phase'] = 'fine'
            fine_results.append(result)
            print(f"✓ λ={kde_weight:.4f}: Acc={result['accuracy']:.2f}%, KDE_ECE={result['kde_ece']:.4f}, Std_ECE={result['std_ece']:.4f}")
        else:
            print(f"✗ λ={kde_weight:.4f}: Failed")
    
    # Combine all results
    all_results = coarse_results + fine_results
    
    # Find overall best λ
    best_overall = min(all_results, key=lambda x: x['kde_ece'] + x['std_ece'] if x['kde_ece'] is not None and x['std_ece'] is not None else float('inf'))
    best_lambda = best_overall['kde_weight']
    
    # Phase 3: Final validation with best parameters
    print("\n" + "="*40)
    print("Phase 3: Final Validation")
    print("="*40)
    print(f"Best λ found: {best_lambda}")
    print(f"Final training with λ = {best_lambda} for full epochs...")
    
    # Run final training with full epochs
    final_epochs = 200 if dataset.startswith('cifar') else 90
    success, final_result = run_kde_experiment_with_validation(dataset, arch, best_lambda, final_epochs)
    
    # Summary
    search_summary = {
        'dataset': dataset,
        'architecture': arch,
        'search_epochs': search_epochs,
        'final_epochs': final_epochs,
        'search_range': [0.001, 0.2],
        'coarse_results': coarse_results,
        'fine_results': fine_results,
        'best_lambda': best_lambda,
        'best_coarse_result': best_coarse,
        'best_overall_result': best_overall,
        'final_result': final_result if success else None,
        'timestamp': datetime.now().isoformat()
    }
    
    # Save results
    results_file = f"/home/haolan/SMART/KdeTraining/hyperparameter_search_{dataset}_{arch}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
    os.makedirs(os.path.dirname(results_file), exist_ok=True)
    with open(results_file, 'w') as f:
        json.dump(search_summary, f, indent=2)
    
    print("\n" + "="*60)
    print("HYPERPARAMETER SEARCH COMPLETED")
    print("="*60)
    print(f"Best regularization weight: λ = {best_lambda}")
    print(f"Best validation performance:")
    print(f"  - KDE ECE: {best_overall['kde_ece']:.4f}")
    print(f"  - Standard ECE: {best_overall['std_ece']:.4f}")
    print(f"  - Accuracy: {best_overall['accuracy']:.2f}%")
    
    if success and final_result:
        print(f"\nFinal model performance (full training):")
        print(f"  - KDE ECE: {final_result['kde_ece']:.4f}")
        print(f"  - Standard ECE: {final_result['std_ece']:.4f}")
        print(f"  - Accuracy: {final_result['accuracy']:.2f}%")
    
    print(f"\nResults saved to: {results_file}")
    
    # Recommendation
    print(f"\n🎯 RECOMMENDATION:")
    print(f"Use λ = {best_lambda} for {dataset} {arch}")
    print(f"Command: python train_kde_regularized.py --dataset {dataset} --arch {arch} --kde_weight {best_lambda} --epochs {final_epochs}")
    
    return search_summary

def main():
    import argparse
    
    parser = argparse.ArgumentParser(description='KDE Hyperparameter Search')
    parser.add_argument('--dataset', type=str, default='cifar10',
                       choices=['cifar10', 'cifar100', 'imagenet'],
                       help='Dataset for hyperparameter search')
    parser.add_argument('--arch', type=str, default='resnet50',
                       help='Model architecture')
    parser.add_argument('--search_epochs', type=int, default=50,
                       help='Epochs for hyperparameter search (shorter for efficiency)')
    
    args = parser.parse_args()
    
    kde_hyperparameter_search(args.dataset, args.arch, args.search_epochs)

if __name__ == '__main__':
    main()