#!/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()