all supported algos now in bencmarks/

benchmarks/constraint_satisfaction/test_constraint_benchmark.py

@@ -74,7 +74,7 @@ def main():
     )
     
     # Generate schedules using different methods
-    methods = ['ga', 'pso', 'sa']
+    methods = ['ga', 'pso', 'sa', 'cmaes', 'nsga2', 'adaptive', 'ensemble']
     schedules = []
     
     print(f"Generating {len(methods)} schedules using different optimization methods...")

benchmarks/optimizer_performance/benchmark_optimizers.py

@@ -14,18 +14,71 @@ import os
 # Add project root to path
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../..')))
 
-from DataService.metro_data_generator import MetroDataGenerator
+from DataService.enhanced_generator import EnhancedMetroDataGenerator
 from DataService.schedule_optimizer import MetroScheduleOptimizer
 from greedyOptim.scheduler import TrainsetSchedulingOptimizer
-from greedyOptim.genetic_algorithm import GeneticAlgorithmOptimizer
-from greedyOptim.ortools_optimizers import ORToolsOptimizer
-from greedyOptim.models import OptimizationConfig
+from DataService.metro_models import Route, TrainHealthStatus
+
+# --- Adapters for Uniform Interface ---
+
+class OptimizerAdapter:
+    """Base adapter for different optimizers"""
+    def optimize(self, data: Dict) -> Any:
+        raise NotImplementedError
+
+class GeneticAdapter(OptimizerAdapter):
+    """Adapter for Genetic Algorithm"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='ga')
+
+class PSOAdapter(OptimizerAdapter):
+    """Adapter for Particle Swarm Optimization"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='pso')
+
+class SAAdapter(OptimizerAdapter):
+    """Adapter for Simulated Annealing"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='sa')
+
+class CMAESAdapter(OptimizerAdapter):
+    """Adapter for CMA-ES"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='cmaes')
+
+class NSGA2Adapter(OptimizerAdapter):
+    """Adapter for NSGA-II"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='nsga2')
+
+class AdaptiveAdapter(OptimizerAdapter):
+    """Adapter for Adaptive Algorithm"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='adaptive')
+
+class EnsembleAdapter(OptimizerAdapter):
+    """Adapter for Ensemble Method"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='ensemble')
+
+class ORToolsAdapter(OptimizerAdapter):
+    """Adapter for OR-Tools CP-SAT"""
+    def optimize(self, data: Dict) -> Any:
+        optimizer = TrainsetSchedulingOptimizer(data)
+        return optimizer.optimize(method='cp-sat')
 
 
 class OptimizerBenchmark:
     """Benchmark different optimization algorithms"""
     
-    def __init__(self, num_trains: int = 25, num_stations: int = 22):
+    def __init__(self):
         self.results = {
             "benchmark_info": {
                 "date": datetime.now().isoformat(),
@@ -34,78 +87,61 @@ class OptimizerBenchmark:
             "test_configurations": [],
             "results": []
         }
-        self.data_generator = MetroDataGenerator(num_trains=num_trains, num_stations=num_stations)
     
-    def generate_test_data(self):
+    def generate_test_data(self, num_trains: int) -> Dict:
         """Generate consistent test data for all optimizers"""
-        route = self.data_generator.generate_route(
-            route_name="Aluva-Pettah Line"
-        )
-        
-        trains = self.data_generator.generate_train_health_statuses()
-        # Limit to requested number
-        trains = trains[:num_trains]
-        
-        return route, trains
+        generator = EnhancedMetroDataGenerator(num_trainsets=num_trains)
+        # We need the full dataset as expected by TrainsetSchedulingEvaluator
+        full_data = generator.generate_complete_enhanced_dataset()
+        return full_data
     
     def benchmark_optimizer(
         self,
         optimizer_name: str,
-        optimizer_class,
+        adapter_class,
         num_trains: int,
-        num_stations: int = 22,
         num_runs: int = 3
     ) -> Dict[str, Any]:
         """Benchmark a single optimizer"""
         print(f"\n{'='*70}")
         print(f"Benchmarking: {optimizer_name}")
-        print(f"Fleet Size: {num_trains} trains | Stations: {num_stations}")
+        print(f"Fleet Size: {num_trains} trains")
         print(f"{'='*70}")
         
         run_times = []
         success_count = 0
-        schedules_generated = []
         
         for run in range(num_runs):
-            print(f"\nRun {run + 1}/{num_runs}...", end=" ")
+            print(f"Run {run + 1}/{num_runs}...", end=" ", flush=True)
             
             try:
                 # Generate fresh data for each run
-                route, trains = self.generate_test_data(num_trains, num_stations)
-                
-                # Create request
-                request = ScheduleRequest(
-                    date=date.today(),
-                    num_trains=num_trains,
-                    route=route,
-                    trains=trains
-                )
+                data = self.generate_test_data(num_trains)
                 
                 # Time the optimization
                 start_time = time.perf_counter()
                 
-                optimizer = optimizer_class()
-                schedule = optimizer.optimize(request)
+                adapter = adapter_class()
+                result = adapter.optimize(data)
                 
                 end_time = time.perf_counter()
                 elapsed = end_time - start_time
                 
                 run_times.append(elapsed)
                 success_count += 1
-                schedules_generated.append(schedule)
                 
-                print(f"✓ Completed in {elapsed:.4f}s")
+                print(f"✓ Completed in {elapsed:.4f}s | Fitness: {result.fitness_score:.2f}")
                 
             except Exception as e:
-                print(f"✗ Failed: {str(e)[:50]}")
-                continue
+                print(f"✗ Failed: {str(e)[:100]}")
+                # import traceback
+                # traceback.print_exc()
         
         # Calculate statistics
         if run_times:
             result = {
                 "optimizer": optimizer_name,
                 "fleet_size": num_trains,
-                "num_stations": num_stations,
                 "num_runs": num_runs,
                 "successful_runs": success_count,
                 "success_rate": f"{(success_count/num_runs)*100:.1f}%",
@@ -113,17 +149,13 @@ class OptimizerBenchmark:
                     "min_seconds": min(run_times),
                     "max_seconds": max(run_times),
                     "mean_seconds": statistics.mean(run_times),
-                    "median_seconds": statistics.median(run_times),
-                    "stdev_seconds": statistics.stdev(run_times) if len(run_times) > 1 else 0,
-                    "all_runs": run_times
-                },
-                "schedule_quality": self._analyze_schedules(schedules_generated) if schedules_generated else None
+                    "stdev_seconds": statistics.stdev(run_times) if len(run_times) > 1 else 0
+                }
             }
         else:
             result = {
                 "optimizer": optimizer_name,
                 "fleet_size": num_trains,
-                "num_stations": num_stations,
                 "num_runs": num_runs,
                 "successful_runs": 0,
                 "success_rate": "0%",
@@ -134,45 +166,12 @@ class OptimizerBenchmark:
         print(f"  Success Rate: {result['success_rate']}")
         if run_times:
             print(f"  Average Time: {result['execution_times']['mean_seconds']:.4f}s")
-            print(f"  Std Dev: {result['execution_times']['stdev_seconds']:.4f}s")
         
         return result
-    
-    def _analyze_schedules(self, schedules: List) -> Dict[str, Any]:
-        """Analyze quality metrics of generated schedules"""
-        if not schedules:
-            return None
-        
-        total_trips_list = []
-        trains_used_list = []
-        
-        for schedule in schedules:
-            if hasattr(schedule, 'trips'):
-                total_trips_list.append(len(schedule.trips))
-            if hasattr(schedule, 'train_schedules'):
-                trains_used_list.append(len(schedule.train_schedules))
-        
-        quality = {}
-        
-        if total_trips_list:
-            quality["trips"] = {
-                "mean": statistics.mean(total_trips_list),
-                "min": min(total_trips_list),
-                "max": max(total_trips_list)
-            }
-        
-        if trains_used_list:
-            quality["trains_utilized"] = {
-                "mean": statistics.mean(trains_used_list),
-                "min": min(trains_used_list),
-                "max": max(trains_used_list)
-            }
-        
-        return quality if quality else None
-    
+
     def run_comprehensive_benchmark(
         self,
-        fleet_sizes: List[int] = [5, 10, 15, 20, 25, 30],
+        fleet_sizes: List[int] = [10, 20, 30],
         num_runs: int = 3
     ):
         """Run comprehensive benchmark across all optimizers and fleet sizes"""
@@ -185,19 +184,14 @@ class OptimizerBenchmark:
         
         # Define optimizers to test
         optimizers = [
-            ("Greedy Optimizer", GreedyScheduleOptimizer),
-            ("Genetic Algorithm", GeneticScheduleOptimizer),
-            ("OR-Tools CP-SAT", ORToolsScheduleOptimizer),
-        ]
-        
-        # Store test configurations
-        self.results["test_configurations"] = [
-            {
-                "fleet_sizes": fleet_sizes,
-                "num_stations": 22,
-                "runs_per_config": num_runs,
-                "optimizers": [name for name, _ in optimizers]
-            }
+            ("Genetic Algorithm", GeneticAdapter),
+            ("Particle Swarm", PSOAdapter),
+            ("Simulated Annealing", SAAdapter),
+            ("CMA-ES", CMAESAdapter),
+            ("NSGA-II", NSGA2Adapter),
+            ("Adaptive Algorithm", AdaptiveAdapter),
+            ("Ensemble Method", EnsembleAdapter),
+            # ("OR-Tools CP-SAT", ORToolsAdapter), # Uncomment if OR-Tools is installed
         ]
         
         # Run benchmarks
@@ -206,10 +200,10 @@ class OptimizerBenchmark:
             print(f"# FLEET SIZE: {fleet_size} TRAINS")
             print(f"{'#'*70}")
             
-            for optimizer_name, optimizer_class in optimizers:
+            for optimizer_name, adapter_class in optimizers:
                 result = self.benchmark_optimizer(
                     optimizer_name,
-                    optimizer_class,
+                    adapter_class,
                     fleet_size,
                     num_runs=num_runs
                 )
@@ -220,6 +214,13 @@ class OptimizerBenchmark:
         
         # Generate comparison summary
         self._generate_summary()
+        
+        # Save results
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"optimizer_benchmark_{timestamp}.json"
+        with open(filename, 'w') as f:
+            json.dump(self.results, f, indent=2)
+        print(f"\nResults saved to: {filename}")
     
     def _generate_summary(self):
         """Generate comparative summary of results"""
@@ -249,183 +250,112 @@ class OptimizerBenchmark:
                 avg_time = result["execution_times"]["mean_seconds"] if "execution_times" in result else "N/A"
                 success = result["success_rate"]
                 
-                if avg_time != "N/A":
-                    print(f"{optimizer:<25} {avg_time:<15.4f} {success:<15}")
+                if isinstance(avg_time, float):
+                    time_str = f"{avg_time:.4f}"
+                else:
+                    time_str = str(avg_time)
+                    
+                print(f"{optimizer:<25} {time_str:<15} {success:<15}")
+                
+                if isinstance(avg_time, float):
                     fleet_summary.append({
                         "optimizer": optimizer,
-                        "avg_time": avg_time,
-                        "success_rate": success
+                        "time": avg_time
                     })
-                else:
-                    print(f"{optimizer:<25} {'FAILED':<15} {success:<15}")
             
+            # Rank for this fleet size
+            fleet_summary.sort(key=lambda x: x["time"])
             summary["by_fleet_size"][fleet_size] = fleet_summary
+            
+            # Update overall stats
+            for item in fleet_summary:
+                opt = item["optimizer"]
+                if opt not in summary["overall_rankings"]:
+                    summary["overall_rankings"][opt] = []
+                summary["overall_rankings"][opt].append(item["time"])
         
-        # Overall performance ranking
+        # Print overall rankings
         print("\n" + "="*70)
-        print("OVERALL PERFORMANCE RANKING")
+        print("OVERALL PERFORMANCE RANKINGS (by average time)")
         print("="*70)
-        
-        optimizer_avg_times = {}
-        for result in self.results["results"]:
-            if "execution_times" in result:
-                optimizer = result["optimizer"]
-                if optimizer not in optimizer_avg_times:
-                    optimizer_avg_times[optimizer] = []
-                optimizer_avg_times[optimizer].append(result["execution_times"]["mean_seconds"])
-        
-        rankings = []
-        for optimizer, times in optimizer_avg_times.items():
-            avg = statistics.mean(times)
-            rankings.append((optimizer, avg))
-        
-        rankings.sort(key=lambda x: x[1])
-        
-        print(f"\n{'Rank':<8} {'Optimizer':<25} {'Avg Time (s)':<15}")
+        print(f"{'Rank':<8} {'Optimizer/Method':<30} {'Avg Time (s)':<15}")
         print("-" * 70)
-        for rank, (optimizer, avg_time) in enumerate(rankings, 1):
-            print(f"{rank:<8} {optimizer:<25} {avg_time:<15.4f}")
-            summary["overall_rankings"][optimizer] = {
-                "rank": rank,
-                "avg_time_seconds": avg_time
-            }
         
-        self.results["summary"] = summary
-    
-    def save_results(self, filename: str = None):
-        """Save benchmark results to JSON file"""
-        if filename is None:
-            filename = f"benchmark_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        overall_stats = []
+        for opt, times in summary["overall_rankings"].items():
+            if times:
+                overall_stats.append({
+                    "optimizer": opt,
+                    "avg_time": statistics.mean(times)
+                })
         
-        with open(filename, 'w') as f:
-            json.dump(self.results, f, indent=2, default=str)
+        overall_stats.sort(key=lambda x: x["avg_time"])
         
-        print(f"\n{'='*70}")
-        print(f"Results saved to: {filename}")
-        print(f"{'='*70}")
+        for i, stat in enumerate(overall_stats):
+            print(f"{i+1:<8} {stat['optimizer']:<30} {stat['avg_time']:.4f}")
         
-        return filename
-    
-    def generate_performance_report(self):
-        """Generate a formatted performance report"""
-        report_filename = f"performance_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+        # Save report to text file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        report_file = f"optimizer_performance_report_{timestamp}.txt"
         
-        with open(report_filename, 'w') as f:
-            f.write("="*80 + "\n")
-            f.write("METRO SCHEDULE OPTIMIZER PERFORMANCE REPORT\n")
-            f.write("="*80 + "\n\n")
-            f.write(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
-            
-            # Executive Summary
-            f.write("EXECUTIVE SUMMARY\n")
-            f.write("-"*80 + "\n")
-            if "summary" in self.results and "overall_rankings" in self.results["summary"]:
-                f.write("\nOverall Performance Ranking:\n")
-                for optimizer, data in self.results["summary"]["overall_rankings"].items():
-                    f.write(f"  {data['rank']}. {optimizer}: {data['avg_time_seconds']:.4f}s average\n")
-            f.write("\n")
-            
-            # Detailed Results
-            f.write("\nDETAILED RESULTS BY FLEET SIZE\n")
-            f.write("-"*80 + "\n\n")
+        with open(report_file, "w") as f:
+            f.write("OPTIMIZER PERFORMANCE BENCHMARK REPORT\n")
+            f.write(f"Date: {datetime.now().isoformat()}\n")
+            f.write("="*70 + "\n\n")
             
-            for result in self.results["results"]:
-                f.write(f"Optimizer: {result['optimizer']}\n")
-                f.write(f"Fleet Size: {result['fleet_size']} trains\n")
-                f.write(f"Success Rate: {result['success_rate']}\n")
+            for fleet_size in fleet_sizes:
+                f.write(f"Fleet Size: {fleet_size} trains\n")
+                f.write("-" * 70 + "\n")
+                f.write(f"{'Optimizer':<25} {'Avg Time (s)':<15} {'Success Rate':<15}\n")
+                f.write("-" * 70 + "\n")
                 
-                if "execution_times" in result:
-                    f.write(f"Execution Time:\n")
-                    f.write(f"  Mean:   {result['execution_times']['mean_seconds']:.4f}s\n")
-                    f.write(f"  Median: {result['execution_times']['median_seconds']:.4f}s\n")
-                    f.write(f"  Min:    {result['execution_times']['min_seconds']:.4f}s\n")
-                    f.write(f"  Max:    {result['execution_times']['max_seconds']:.4f}s\n")
-                    f.write(f"  StdDev: {result['execution_times']['stdev_seconds']:.4f}s\n")
-                
-                if result.get("schedule_quality"):
-                    f.write(f"Schedule Quality:\n")
-                    if "trips" in result["schedule_quality"]:
-                        f.write(f"  Trips Generated (avg): {result['schedule_quality']['trips']['mean']:.1f}\n")
-                    if "trains_utilized" in result["schedule_quality"]:
-                        f.write(f"  Trains Utilized (avg): {result['schedule_quality']['trains_utilized']['mean']:.1f}\n")
-                
-                f.write("\n" + "-"*80 + "\n\n")
-            
-            # Recommendations
-            f.write("\nRECOMMENDATIONS\n")
-            f.write("-"*80 + "\n")
-            f.write("Based on the benchmark results:\n\n")
-            
-            if "summary" in self.results and "overall_rankings" in self.results["summary"]:
-                rankings = sorted(
-                    self.results["summary"]["overall_rankings"].items(),
-                    key=lambda x: x[1]["rank"]
-                )
-                if rankings:
-                    fastest = rankings[0]
-                    f.write(f"• {fastest[0]} showed the best overall performance\n")
-                    f.write(f"  with an average execution time of {fastest[1]['avg_time_seconds']:.4f}s\n\n")
+                fleet_results = [r for r in self.results["results"] if r["fleet_size"] == fleet_size]
+                for result in fleet_results:
+                    optimizer = result["optimizer"]
+                    avg_time = result["execution_times"]["mean_seconds"] if "execution_times" in result else "N/A"
+                    success = result["success_rate"]
+                    
+                    if isinstance(avg_time, float):
+                        time_str = f"{avg_time:.4f}"
+                    else:
+                        time_str = str(avg_time)
+                        
+                    f.write(f"{optimizer:<25} {time_str:<15} {success:<15}\n")
+                f.write("\n")
             
-            f.write("• Consider using faster optimizers for real-time scheduling\n")
-            f.write("• Slower optimizers may provide better solution quality for offline planning\n")
-            f.write("• Test with your specific constraints and requirements\n\n")
-        
-        print(f"Performance report saved to: {report_filename}")
-        return report_filename
-
+            f.write("="*70 + "\n")
+            f.write("OVERALL RANKINGS\n")
+            f.write("="*70 + "\n")
+            for i, stat in enumerate(overall_stats):
+                f.write(f"{i+1}. {stat['optimizer']}: {stat['avg_time']:.4f}s\n")
+                
+        print(f"\nPerformance report saved to: {report_file}")
 
 def main():
-    """Main execution function"""
     import argparse
-    
     parser = argparse.ArgumentParser(description="Benchmark metro schedule optimizers")
-    parser.add_argument(
-        "--fleet-sizes",
-        nargs="+",
-        type=int,
-        default=[5, 10, 15, 20, 25, 30],
-        help="Fleet sizes to test (default: 5 10 15 20 25 30)"
-    )
-    parser.add_argument(
-        "--runs",
-        type=int,
-        default=3,
-        help="Number of runs per configuration (default: 3)"
-    )
-    parser.add_argument(
-        "--quick",
-        action="store_true",
-        help="Quick test with fewer configurations"
-    )
+    parser.add_argument("--fleet-sizes", type=int, nargs="+", default=[10, 20, 30],
+                        help="Fleet sizes to test (default: 10 20 30)")
+    parser.add_argument("--runs", type=int, default=3,
+                        help="Number of runs per configuration (default: 3)")
+    parser.add_argument("--quick", action="store_true",
+                        help="Quick test with fewer configurations")
     
     args = parser.parse_args()
     
     if args.quick:
-        fleet_sizes = [10, 20, 30]
-        num_runs = 2
         print("\n*** QUICK BENCHMARK MODE ***")
+        fleet_sizes = [10, 20]
+        runs = 1
     else:
         fleet_sizes = args.fleet_sizes
-        num_runs = args.runs
+        runs = args.runs
     
-    # Run benchmark
     benchmark = OptimizerBenchmark()
     benchmark.run_comprehensive_benchmark(
         fleet_sizes=fleet_sizes,
-        num_runs=num_runs
+        num_runs=runs
     )
-    
-    # Save results
-    json_file = benchmark.save_results()
-    report_file = benchmark.generate_performance_report()
-    
-    print("\n" + "="*70)
-    print("BENCHMARK COMPLETE")
-    print("="*70)
-    print(f"JSON Results: {json_file}")
-    print(f"Text Report:  {report_file}")
-    print("="*70 + "\n")
-
 
 if __name__ == "__main__":
     main()

benchmarks/optimizer_performance/benchmark_schedule_performance.py

@@ -152,7 +152,7 @@ class SchedulePerformanceBenchmark:
     def benchmark_greedy_optimizers(
         self,
         num_trains: int,
-        methods: List[str] = ['ga', 'cmaes', 'pso'],
+        methods: List[str] = ['ga', 'cmaes', 'pso', 'sa', 'nsga2', 'adaptive', 'ensemble'],
         num_runs: int = 3
     ) -> Dict[str, List[Dict[str, Any]]]:
         """Benchmark greedyOptim methods"""
@@ -451,8 +451,8 @@ def main():
     parser.add_argument(
         "--methods",
         nargs="+",
-        default=['ga', 'cmaes', 'pso'],
-        help="Greedy optimization methods to test (default: ga cmaes pso)"
+        default=['ga', 'cmaes', 'pso', 'sa', 'nsga2', 'adaptive', 'ensemble'],
+        help="Greedy optimization methods to test (default: ga cmaes pso sa nsga2 adaptive ensemble)"
     )
     parser.add_argument(
         "--runs",

benchmarks/service_quality/benchmark_service_quality.py

@@ -1,214 +0,0 @@
-"""
-Service Quality Benchmark Script
-Runs comprehensive benchmarks for headway consistency, wait times, and coverage.
-"""
-import time
-import json
-from typing import Dict, List
-from datetime import datetime
-
-from .service_analyzer import ServiceQualityAnalyzer, ServiceQualityMetrics
-
-
-def run_service_quality_benchmark(
-    schedules: List[Dict],
-    output_file: str = "service_quality_benchmark_results.json",
-    verbose: bool = True
-) -> Dict:
-    """Run service quality benchmark on multiple schedules.
-    
-    Args:
-        schedules: List of schedule dictionaries to analyze
-        output_file: Path to save results JSON
-        verbose: Whether to print detailed output
-        
-    Returns:
-        Dictionary with benchmark results
-    """
-    if verbose:
-        print("=" * 80)
-        print("SERVICE QUALITY BENCHMARK")
-        print("=" * 80)
-        print(f"Analyzing {len(schedules)} schedules...")
-        print()
-    
-    analyzer = ServiceQualityAnalyzer()
-    start_time = time.time()
-    
-    results = []
-    
-    # Analyze each schedule
-    for i, schedule in enumerate(schedules, 1):
-        if verbose:
-            print(f"Schedule {i}/{len(schedules)}:")
-        
-        schedule_start = time.time()
-        metrics = analyzer.analyze_schedule(schedule)
-        analysis_time = (time.time() - schedule_start) * 1000  # ms
-        
-        result = {
-            'schedule_id': i,
-            'analysis_time_ms': round(analysis_time, 2),
-            'metrics': {
-                'headway_consistency': {
-                    'peak_mean_minutes': round(metrics.peak_headway_mean, 2),
-                    'peak_std_minutes': round(metrics.peak_headway_std, 2),
-                    'peak_cv': round(metrics.peak_headway_coefficient_variation, 3),
-                    'offpeak_mean_minutes': round(metrics.offpeak_headway_mean, 2),
-                    'offpeak_std_minutes': round(metrics.offpeak_headway_std, 2),
-                    'offpeak_cv': round(metrics.offpeak_headway_coefficient_variation, 3),
-                    'score': round(metrics.headway_consistency_score, 2)
-                },
-                'wait_times': {
-                    'avg_wait_peak_minutes': round(metrics.avg_wait_time_peak, 2),
-                    'max_wait_peak_minutes': round(metrics.max_wait_time_peak, 2),
-                    'avg_wait_offpeak_minutes': round(metrics.avg_wait_time_offpeak, 2),
-                    'max_wait_offpeak_minutes': round(metrics.max_wait_time_offpeak, 2),
-                    'reduction_vs_baseline_percent': round(metrics.wait_time_reduction_vs_baseline, 2),
-                    'score': round(metrics.wait_time_score, 2)
-                },
-                'service_coverage': {
-                    'operational_hours': round(metrics.operational_hours, 2),
-                    'peak_hours_covered': round(metrics.peak_hours_covered, 2),
-                    'offpeak_hours_covered': round(metrics.offpeak_hours_covered, 2),
-                    'coverage_percent': round(metrics.service_coverage_percent, 2),
-                    'peak_coverage_percent': round(metrics.peak_coverage_percent, 2),
-                    'service_gaps': metrics.gaps_in_service,
-                    'score': round(metrics.coverage_score, 2)
-                },
-                'overall_quality_score': round(metrics.overall_quality_score, 2)
-            }
-        }
-        
-        results.append(result)
-        
-        if verbose:
-            print(f"  Headway Consistency Score: {result['metrics']['headway_consistency']['score']:.2f}/100")
-            print(f"    Peak: {metrics.peak_headway_mean:.1f}min ± {metrics.peak_headway_std:.1f}min (CV: {metrics.peak_headway_coefficient_variation:.3f})")
-            print(f"    Off-Peak: {metrics.offpeak_headway_mean:.1f}min ± {metrics.offpeak_headway_std:.1f}min (CV: {metrics.offpeak_headway_coefficient_variation:.3f})")
-            print(f"  Wait Time Score: {result['metrics']['wait_times']['score']:.2f}/100")
-            print(f"    Peak avg wait: {metrics.avg_wait_time_peak:.1f}min (max: {metrics.max_wait_time_peak:.1f}min)")
-            print(f"    Off-peak avg wait: {metrics.avg_wait_time_offpeak:.1f}min (max: {metrics.max_wait_time_offpeak:.1f}min)")
-            print(f"    Improvement vs baseline: {metrics.wait_time_reduction_vs_baseline:.1f}%")
-            print(f"  Coverage Score: {result['metrics']['service_coverage']['score']:.2f}/100")
-            print(f"    Peak coverage: {metrics.peak_coverage_percent:.1f}%")
-            print(f"    Overall coverage: {metrics.service_coverage_percent:.1f}%")
-            print(f"    Service gaps: {metrics.gaps_in_service}")
-            print(f"  OVERALL QUALITY: {metrics.overall_quality_score:.2f}/100")
-            print(f"  Analysis time: {analysis_time:.2f}ms")
-            print()
-    
-    total_time = time.time() - start_time
-    
-    # Calculate aggregate statistics
-    aggregate = _calculate_aggregate_stats(results)
-    
-    # Prepare final output
-    benchmark_results = {
-        'benchmark_info': {
-            'timestamp': datetime.now().isoformat(),
-            'total_schedules': len(schedules),
-            'total_time_seconds': round(total_time, 3),
-            'avg_analysis_time_ms': round(aggregate['avg_analysis_time_ms'], 2)
-        },
-        'aggregate_metrics': aggregate,
-        'individual_results': results
-    }
-    
-    # Print summary
-    if verbose:
-        print("=" * 80)
-        print("AGGREGATE RESULTS")
-        print("=" * 80)
-        print(f"Schedules analyzed: {len(schedules)}")
-        print(f"Total benchmark time: {total_time:.2f}s")
-        print()
-        print("Average Scores:")
-        print(f"  Headway Consistency: {aggregate['avg_headway_score']:.2f}/100")
-        print(f"  Wait Time Quality: {aggregate['avg_wait_score']:.2f}/100")
-        print(f"  Service Coverage: {aggregate['avg_coverage_score']:.2f}/100")
-        print(f"  Overall Quality: {aggregate['avg_overall_score']:.2f}/100")
-        print()
-        print("Best Performers:")
-        print(f"  Best headway consistency: Schedule {aggregate['best_headway_schedule']} ({aggregate['best_headway_score']:.2f})")
-        print(f"  Best wait times: Schedule {aggregate['best_wait_schedule']} ({aggregate['best_wait_score']:.2f})")
-        print(f"  Best coverage: Schedule {aggregate['best_coverage_schedule']} ({aggregate['best_coverage_score']:.2f})")
-        print(f"  Best overall: Schedule {aggregate['best_overall_schedule']} ({aggregate['best_overall_score']:.2f})")
-        print()
-        print("Service Quality Metrics:")
-        print(f"  Avg peak headway: {aggregate['avg_peak_headway']:.2f} ± {aggregate['avg_peak_headway_std']:.2f} minutes")
-        print(f"  Avg off-peak headway: {aggregate['avg_offpeak_headway']:.2f} ± {aggregate['avg_offpeak_headway_std']:.2f} minutes")
-        print(f"  Avg peak wait time: {aggregate['avg_peak_wait']:.2f} minutes")
-        print(f"  Avg wait time reduction: {aggregate['avg_wait_reduction']:.1f}%")
-        print(f"  Avg service coverage: {aggregate['avg_coverage_percent']:.1f}%")
-        print(f"  Avg service gaps: {aggregate['avg_service_gaps']:.1f}")
-        print()
-    
-    # Save to file
-    with open(output_file, 'w') as f:
-        json.dump(benchmark_results, f, indent=2)
-    
-    if verbose:
-        print(f"Results saved to: {output_file}")
-        print("=" * 80)
-    
-    return benchmark_results
-
-
-def _calculate_aggregate_stats(results: List[Dict]) -> Dict:
-    """Calculate aggregate statistics across all results."""
-    if not results:
-        return {}
-    
-    # Extract all metrics
-    headway_scores = [r['metrics']['headway_consistency']['score'] for r in results]
-    wait_scores = [r['metrics']['wait_times']['score'] for r in results]
-    coverage_scores = [r['metrics']['service_coverage']['score'] for r in results]
-    overall_scores = [r['metrics']['overall_quality_score'] for r in results]
-    
-    peak_headways = [r['metrics']['headway_consistency']['peak_mean_minutes'] for r in results]
-    peak_headway_stds = [r['metrics']['headway_consistency']['peak_std_minutes'] for r in results]
-    offpeak_headways = [r['metrics']['headway_consistency']['offpeak_mean_minutes'] for r in results]
-    offpeak_headway_stds = [r['metrics']['headway_consistency']['offpeak_std_minutes'] for r in results]
-    peak_waits = [r['metrics']['wait_times']['avg_wait_peak_minutes'] for r in results]
-    wait_reductions = [r['metrics']['wait_times']['reduction_vs_baseline_percent'] for r in results]
-    coverage_percents = [r['metrics']['service_coverage']['coverage_percent'] for r in results]
-    service_gaps = [r['metrics']['service_coverage']['service_gaps'] for r in results]
-    analysis_times = [r['analysis_time_ms'] for r in results]
-    
-    # Find best performers
-    best_headway_idx = headway_scores.index(max(headway_scores))
-    best_wait_idx = wait_scores.index(max(wait_scores))
-    best_coverage_idx = coverage_scores.index(max(coverage_scores))
-    best_overall_idx = overall_scores.index(max(overall_scores))
-    
-    return {
-        'avg_headway_score': round(sum(headway_scores) / len(headway_scores), 2),
-        'avg_wait_score': round(sum(wait_scores) / len(wait_scores), 2),
-        'avg_coverage_score': round(sum(coverage_scores) / len(coverage_scores), 2),
-        'avg_overall_score': round(sum(overall_scores) / len(overall_scores), 2),
-        
-        'best_headway_schedule': best_headway_idx + 1,
-        'best_headway_score': round(max(headway_scores), 2),
-        'best_wait_schedule': best_wait_idx + 1,
-        'best_wait_score': round(max(wait_scores), 2),
-        'best_coverage_schedule': best_coverage_idx + 1,
-        'best_coverage_score': round(max(coverage_scores), 2),
-        'best_overall_schedule': best_overall_idx + 1,
-        'best_overall_score': round(max(overall_scores), 2),
-        
-        'avg_peak_headway': round(sum(peak_headways) / len(peak_headways), 2),
-        'avg_peak_headway_std': round(sum(peak_headway_stds) / len(peak_headway_stds), 2),
-        'avg_offpeak_headway': round(sum(offpeak_headways) / len(offpeak_headways), 2),
-        'avg_offpeak_headway_std': round(sum(offpeak_headway_stds) / len(offpeak_headway_stds), 2),
-        'avg_peak_wait': round(sum(peak_waits) / len(peak_waits), 2),
-        'avg_wait_reduction': round(sum(wait_reductions) / len(wait_reductions), 2),
-        'avg_coverage_percent': round(sum(coverage_percents) / len(coverage_percents), 2),
-        'avg_service_gaps': round(sum(service_gaps) / len(service_gaps), 2),
-        'avg_analysis_time_ms': round(sum(analysis_times) / len(analysis_times), 2)
-    }
-
-
-if __name__ == "__main__":
-    print("Service Quality Benchmark Module")
-    print("Import and use run_service_quality_benchmark() to analyze schedules")

benchmarks/service_quality/test_service_quality_benchmark.py

@@ -1,7 +1,8 @@
 """
-Test Service Quality Benchmark
-Direct test of the service quality benchmarking system.
+Service Quality Benchmark Script
+Runs comprehensive benchmarks for headway consistency, wait times, and coverage.
 """
+
 import sys
 import os
 
@@ -12,7 +13,212 @@ from DataService.enhanced_generator import EnhancedMetroDataGenerator
 from greedyOptim.scheduler import TrainsetSchedulingOptimizer
 from greedyOptim.models import OptimizationConfig
 from greedyOptim.service_blocks import create_service_blocks_for_schedule
-from benchmarks.service_quality import run_service_quality_benchmark
+
+import time
+import json
+from typing import Dict, List
+from datetime import datetime
+
+from .service_analyzer import ServiceQualityAnalyzer, ServiceQualityMetrics
+
+
+def run_service_quality_benchmark(
+    schedules: List[Dict],
+    output_file: str = "service_quality_benchmark_results.json",
+    verbose: bool = True
+) -> Dict:
+    """Run service quality benchmark on multiple schedules.
+    
+    Args:
+        schedules: List of schedule dictionaries to analyze
+        output_file: Path to save results JSON
+        verbose: Whether to print detailed output
+        
+    Returns:
+        Dictionary with benchmark results
+    """
+    if verbose:
+        print("=" * 80)
+        print("SERVICE QUALITY BENCHMARK")
+        print("=" * 80)
+        print(f"Analyzing {len(schedules)} schedules...")
+        print()
+    
+    analyzer = ServiceQualityAnalyzer()
+    start_time = time.time()
+    
+    results = []
+    
+    # Analyze each schedule
+    for i, schedule in enumerate(schedules, 1):
+        if verbose:
+            print(f"Schedule {i}/{len(schedules)}:")
+        
+        schedule_start = time.time()
+        metrics = analyzer.analyze_schedule(schedule)
+        analysis_time = (time.time() - schedule_start) * 1000  # ms
+        
+        result = {
+            'schedule_id': i,
+            'analysis_time_ms': round(analysis_time, 2),
+            'metrics': {
+                'headway_consistency': {
+                    'peak_mean_minutes': round(metrics.peak_headway_mean, 2),
+                    'peak_std_minutes': round(metrics.peak_headway_std, 2),
+                    'peak_cv': round(metrics.peak_headway_coefficient_variation, 3),
+                    'offpeak_mean_minutes': round(metrics.offpeak_headway_mean, 2),
+                    'offpeak_std_minutes': round(metrics.offpeak_headway_std, 2),
+                    'offpeak_cv': round(metrics.offpeak_headway_coefficient_variation, 3),
+                    'score': round(metrics.headway_consistency_score, 2)
+                },
+                'wait_times': {
+                    'avg_wait_peak_minutes': round(metrics.avg_wait_time_peak, 2),
+                    'max_wait_peak_minutes': round(metrics.max_wait_time_peak, 2),
+                    'avg_wait_offpeak_minutes': round(metrics.avg_wait_time_offpeak, 2),
+                    'max_wait_offpeak_minutes': round(metrics.max_wait_time_offpeak, 2),
+                    'reduction_vs_baseline_percent': round(metrics.wait_time_reduction_vs_baseline, 2),
+                    'score': round(metrics.wait_time_score, 2)
+                },
+                'service_coverage': {
+                    'operational_hours': round(metrics.operational_hours, 2),
+                    'peak_hours_covered': round(metrics.peak_hours_covered, 2),
+                    'offpeak_hours_covered': round(metrics.offpeak_hours_covered, 2),
+                    'coverage_percent': round(metrics.service_coverage_percent, 2),
+                    'peak_coverage_percent': round(metrics.peak_coverage_percent, 2),
+                    'service_gaps': metrics.gaps_in_service,
+                    'score': round(metrics.coverage_score, 2)
+                },
+                'overall_quality_score': round(metrics.overall_quality_score, 2)
+            }
+        }
+        
+        results.append(result)
+        
+        if verbose:
+            print(f"  Headway Consistency Score: {result['metrics']['headway_consistency']['score']:.2f}/100")
+            print(f"    Peak: {metrics.peak_headway_mean:.1f}min ± {metrics.peak_headway_std:.1f}min (CV: {metrics.peak_headway_coefficient_variation:.3f})")
+            print(f"    Off-Peak: {metrics.offpeak_headway_mean:.1f}min ± {metrics.offpeak_headway_std:.1f}min (CV: {metrics.offpeak_headway_coefficient_variation:.3f})")
+            print(f"  Wait Time Score: {result['metrics']['wait_times']['score']:.2f}/100")
+            print(f"    Peak avg wait: {metrics.avg_wait_time_peak:.1f}min (max: {metrics.max_wait_time_peak:.1f}min)")
+            print(f"    Off-peak avg wait: {metrics.avg_wait_time_offpeak:.1f}min (max: {metrics.max_wait_time_offpeak:.1f}min)")
+            print(f"    Improvement vs baseline: {metrics.wait_time_reduction_vs_baseline:.1f}%")
+            print(f"  Coverage Score: {result['metrics']['service_coverage']['score']:.2f}/100")
+            print(f"    Peak coverage: {metrics.peak_coverage_percent:.1f}%")
+            print(f"    Overall coverage: {metrics.service_coverage_percent:.1f}%")
+            print(f"    Service gaps: {metrics.gaps_in_service}")
+            print(f"  OVERALL QUALITY: {metrics.overall_quality_score:.2f}/100")
+            print(f"  Analysis time: {analysis_time:.2f}ms")
+            print()
+    
+    total_time = time.time() - start_time
+    
+    # Calculate aggregate statistics
+    aggregate = _calculate_aggregate_stats(results)
+    
+    # Prepare final output
+    benchmark_results = {
+        'benchmark_info': {
+            'timestamp': datetime.now().isoformat(),
+            'total_schedules': len(schedules),
+            'total_time_seconds': round(total_time, 3),
+            'avg_analysis_time_ms': round(aggregate['avg_analysis_time_ms'], 2)
+        },
+        'aggregate_metrics': aggregate,
+        'individual_results': results
+    }
+    
+    # Print summary
+    if verbose:
+        print("=" * 80)
+        print("AGGREGATE RESULTS")
+        print("=" * 80)
+        print(f"Schedules analyzed: {len(schedules)}")
+        print(f"Total benchmark time: {total_time:.2f}s")
+        print()
+        print("Average Scores:")
+        print(f"  Headway Consistency: {aggregate['avg_headway_score']:.2f}/100")
+        print(f"  Wait Time Quality: {aggregate['avg_wait_score']:.2f}/100")
+        print(f"  Service Coverage: {aggregate['avg_coverage_score']:.2f}/100")
+        print(f"  Overall Quality: {aggregate['avg_overall_score']:.2f}/100")
+        print()
+        print("Best Performers:")
+        print(f"  Best headway consistency: Schedule {aggregate['best_headway_schedule']} ({aggregate['best_headway_score']:.2f})")
+        print(f"  Best wait times: Schedule {aggregate['best_wait_schedule']} ({aggregate['best_wait_score']:.2f})")
+        print(f"  Best coverage: Schedule {aggregate['best_coverage_schedule']} ({aggregate['best_coverage_score']:.2f})")
+        print(f"  Best overall: Schedule {aggregate['best_overall_schedule']} ({aggregate['best_overall_score']:.2f})")
+        print()
+        print("Service Quality Metrics:")
+        print(f"  Avg peak headway: {aggregate['avg_peak_headway']:.2f} ± {aggregate['avg_peak_headway_std']:.2f} minutes")
+        print(f"  Avg off-peak headway: {aggregate['avg_offpeak_headway']:.2f} ± {aggregate['avg_offpeak_headway_std']:.2f} minutes")
+        print(f"  Avg peak wait time: {aggregate['avg_peak_wait']:.2f} minutes")
+        print(f"  Avg wait time reduction: {aggregate['avg_wait_reduction']:.1f}%")
+        print(f"  Avg service coverage: {aggregate['avg_coverage_percent']:.1f}%")
+        print(f"  Avg service gaps: {aggregate['avg_service_gaps']:.1f}")
+        print()
+    
+    # Save to file
+    with open(output_file, 'w') as f:
+        json.dump(benchmark_results, f, indent=2)
+    
+    if verbose:
+        print(f"Results saved to: {output_file}")
+        print("=" * 80)
+    
+    return benchmark_results
+
+
+def _calculate_aggregate_stats(results: List[Dict]) -> Dict:
+    """Calculate aggregate statistics across all results."""
+    if not results:
+        return {}
+    
+    # Extract all metrics
+    headway_scores = [r['metrics']['headway_consistency']['score'] for r in results]
+    wait_scores = [r['metrics']['wait_times']['score'] for r in results]
+    coverage_scores = [r['metrics']['service_coverage']['score'] for r in results]
+    overall_scores = [r['metrics']['overall_quality_score'] for r in results]
+    
+    peak_headways = [r['metrics']['headway_consistency']['peak_mean_minutes'] for r in results]
+    peak_headway_stds = [r['metrics']['headway_consistency']['peak_std_minutes'] for r in results]
+    offpeak_headways = [r['metrics']['headway_consistency']['offpeak_mean_minutes'] for r in results]
+    offpeak_headway_stds = [r['metrics']['headway_consistency']['offpeak_std_minutes'] for r in results]
+    peak_waits = [r['metrics']['wait_times']['avg_wait_peak_minutes'] for r in results]
+    wait_reductions = [r['metrics']['wait_times']['reduction_vs_baseline_percent'] for r in results]
+    coverage_percents = [r['metrics']['service_coverage']['coverage_percent'] for r in results]
+    service_gaps = [r['metrics']['service_coverage']['service_gaps'] for r in results]
+    analysis_times = [r['analysis_time_ms'] for r in results]
+    
+    # Find best performers
+    best_headway_idx = headway_scores.index(max(headway_scores))
+    best_wait_idx = wait_scores.index(max(wait_scores))
+    best_coverage_idx = coverage_scores.index(max(coverage_scores))
+    best_overall_idx = overall_scores.index(max(overall_scores))
+    
+    return {
+        'avg_headway_score': round(sum(headway_scores) / len(headway_scores), 2),
+        'avg_wait_score': round(sum(wait_scores) / len(wait_scores), 2),
+        'avg_coverage_score': round(sum(coverage_scores) / len(coverage_scores), 2),
+        'avg_overall_score': round(sum(overall_scores) / len(overall_scores), 2),
+        
+        'best_headway_schedule': best_headway_idx + 1,
+        'best_headway_score': round(max(headway_scores), 2),
+        'best_wait_schedule': best_wait_idx + 1,
+        'best_wait_score': round(max(wait_scores), 2),
+        'best_coverage_schedule': best_coverage_idx + 1,
+        'best_coverage_score': round(max(coverage_scores), 2),
+        'best_overall_schedule': best_overall_idx + 1,
+        'best_overall_score': round(max(overall_scores), 2),
+        
+        'avg_peak_headway': round(sum(peak_headways) / len(peak_headways), 2),
+        'avg_peak_headway_std': round(sum(peak_headway_stds) / len(peak_headway_stds), 2),
+        'avg_offpeak_headway': round(sum(offpeak_headways) / len(offpeak_headways), 2),
+        'avg_offpeak_headway_std': round(sum(offpeak_headway_stds) / len(offpeak_headway_stds), 2),
+        'avg_peak_wait': round(sum(peak_waits) / len(peak_waits), 2),
+        'avg_wait_reduction': round(sum(wait_reductions) / len(wait_reductions), 2),
+        'avg_coverage_percent': round(sum(coverage_percents) / len(coverage_percents), 2),
+        'avg_service_gaps': round(sum(service_gaps) / len(service_gaps), 2),
+        'avg_analysis_time_ms': round(sum(analysis_times) / len(analysis_times), 2)
+    }
 
 
 def create_schedule_with_service_blocks(result, method_name):
@@ -76,7 +282,7 @@ def main():
     )
     
     # Generate schedules using different methods
-    methods = ['ga', 'pso', 'sa']
+    methods = ['ga', 'pso', 'sa', 'cmaes', 'nsga2', 'adaptive', 'ensemble']
     schedules = []
     
     print(f"Generating {len(methods)} schedules using different optimization methods...")

greedyOptim/hybrid_optimizers.py

@@ -237,9 +237,16 @@ class AdaptiveOptimizer:
                 improvements[name] = 0
         
         # Update probabilities (softmax-like)
-        total_improvement = sum(improvements.values()) + 1e-6
+        # Calculate raw weights
+        weights = {}
         for name in self.optimizers.keys():
-            self.selection_probabilities[name] = (improvements[name] + 0.1) / (total_improvement + 0.4)
+            weights[name] = improvements[name] + 0.1
+            
+        total_weight = sum(weights.values())
+        
+        # Normalize
+        for name in self.optimizers.keys():
+            self.selection_probabilities[name] = weights[name] / total_weight
     
     def select_optimizer(self) -> str:
         """Select optimizer based on adaptive probabilities."""