| """Benchmark engine — compare methods and solvers across instance sizes.""" | |
| from __future__ import annotations | |
| from datetime import datetime, timezone | |
| from optos.constants import PROBLEM_TYPES, SIZE_PRESETS | |
| from optos.engine import OptimizationEngine | |
| from optos.generators import generate_instance | |
| from optos.models import ExperimentRun | |
| class BenchmarkEngine: | |
| def __init__(self, time_limit_sec: float = 10.0) -> None: | |
| self.engine = OptimizationEngine(time_limit_sec) | |
| def run_instance_benchmark( | |
| self, | |
| problem_type: str, | |
| size: str, | |
| seed: int = 42, | |
| ) -> ExperimentRun: | |
| return self.engine.run_experiment(problem_type, size, seed) | |
| def run_problem_suite( | |
| self, | |
| problem_type: str, | |
| sizes: list[str] | None = None, | |
| seeds: list[int] | None = None, | |
| ) -> list[ExperimentRun]: | |
| sizes = sizes or ["small", "medium", "large"] | |
| seeds = seeds or [42, 123] | |
| return [ | |
| self.engine.run_experiment(problem_type, size, seed) | |
| for size in sizes | |
| for seed in seeds | |
| ] | |
| def run_full_benchmark( | |
| self, | |
| sizes: list[str] | None = None, | |
| seeds: list[int] | None = None, | |
| ) -> dict: | |
| sizes = sizes or ["small", "medium", "large"] | |
| seeds = seeds or [42, 123] | |
| rows = [] | |
| comparisons: dict = {} | |
| for pt in PROBLEM_TYPES: | |
| comparisons[pt] = {} | |
| for size in sizes: | |
| for seed in seeds: | |
| run = self.engine.run_experiment(pt, size, seed) | |
| comparisons[pt][f"{size}_s{seed}"] = { | |
| "instance_label": run.instance.label, | |
| "winner": run.winner, | |
| "winner_gap_pct": run.winner_gap_pct, | |
| "results": { | |
| r.method_id: r.metrics.to_dict() for r in run.results | |
| }, | |
| } | |
| for r in run.results: | |
| rows.append({ | |
| "problem_type": pt, | |
| "problem_label": PROBLEM_TYPES[pt]["label"], | |
| "size": size, | |
| "seed": seed, | |
| "instance_id": run.instance.instance_id, | |
| "method_id": r.method_id, | |
| "method_label": r.method_label, | |
| "method_category": r.method_category, | |
| "solver_id": r.solver_id, | |
| "objective_value": r.metrics.objective_value, | |
| "best_bound": r.metrics.best_bound, | |
| "optimality_gap": r.metrics.optimality_gap, | |
| "elapsed_time_sec": r.metrics.elapsed_time_sec, | |
| "iterations": r.metrics.iterations, | |
| "constraint_violations": r.metrics.constraint_violations, | |
| "feasible": r.metrics.feasible, | |
| "status": r.metrics.status, | |
| "winner": r.method_id == run.winner, | |
| "n_variables": run.instance.features.n_variables, | |
| "n_constraints": run.instance.features.n_constraints, | |
| }) | |
| scalability = [] | |
| for row in rows: | |
| scalability.append({ | |
| "problem_type": row["problem_type"], | |
| "size": row["size"], | |
| "method_id": row["method_id"], | |
| "elapsed_time_sec": row["elapsed_time_sec"], | |
| "objective_value": row["objective_value"], | |
| }) | |
| winners: dict[str, int] = {} | |
| for row in rows: | |
| if row.get("winner"): | |
| winners[row["method_id"]] = winners.get(row["method_id"], 0) + 1 | |
| return { | |
| "generated_at": datetime.now(timezone.utc).isoformat(), | |
| "benchmarks": {"rows": rows}, | |
| "comparisons": comparisons, | |
| "scalability": {"rows": scalability}, | |
| "summary": { | |
| "total_runs": len(rows), | |
| "unique_instances": len({r["instance_id"] for r in rows}), | |
| "problem_types": len(PROBLEM_TYPES), | |
| "winner_distribution": winners, | |
| }, | |
| } | |
| def category_comparison(self, runs: list[ExperimentRun]) -> list[dict]: | |
| """Compare baseline vs exact vs scalable vs robust averages.""" | |
| cats: dict[str, list[float]] = {} | |
| for run in runs: | |
| for r in run.results: | |
| if r.metrics.feasible: | |
| cats.setdefault(r.method_category, []).append(r.metrics.objective_value) | |
| return [ | |
| { | |
| "category": cat, | |
| "avg_objective": round(sum(vals) / len(vals), 2), | |
| "count": len(vals), | |
| } | |
| for cat, vals in sorted(cats.items()) | |
| ] | |