File size: 5,151 Bytes
ab849c9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 | """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())
]
|