| """Core optimization engine — dispatches problems to registered methods."""
|
|
|
| from __future__ import annotations
|
|
|
| import time
|
| import uuid
|
|
|
| from optos.constants import ENGINE_VERSION, METHODS, PROBLEM_TYPES
|
| from optos.generators import generate_instance
|
| from optos.methods import get_method
|
| from optos.models import ExperimentRun, ProblemInstance, SolveResult
|
|
|
|
|
| class OptimizationEngine:
|
| def __init__(self, time_limit_sec: float = 15.0) -> None:
|
| self.time_limit_sec = time_limit_sec
|
|
|
| def solve_instance(
|
| self,
|
| instance: ProblemInstance,
|
| methods: list[str] | None = None,
|
| ) -> list[SolveResult]:
|
| pt = instance.problem_type
|
| method_map = METHODS.get(pt, {})
|
| if methods:
|
| method_ids = methods
|
| else:
|
| method_ids = [m["id"] for m in method_map.values()]
|
|
|
| results: list[SolveResult] = []
|
| per_method_limit = self.time_limit_sec / max(len(method_ids), 1)
|
| for mid in method_ids:
|
| try:
|
| solver = get_method(mid, per_method_limit)
|
| results.append(solver.solve(instance))
|
| except Exception as exc:
|
| from optos.models import SolveMetrics
|
| results.append(SolveResult(
|
| method_id=mid,
|
| method_label=mid,
|
| method_category="error",
|
| solver_id="none",
|
| solver_config={},
|
| instance_id=instance.instance_id,
|
| problem_type=pt,
|
| metrics=SolveMetrics(status="error", feasible=False),
|
| log=str(exc),
|
| ))
|
| return results
|
|
|
| def run_experiment(
|
| self,
|
| problem_type: str,
|
| size: str = "medium",
|
| seed: int = 42,
|
| time_limit: float | None = None,
|
| constraints: dict | None = None,
|
| objectives: dict | None = None,
|
| ) -> ExperimentRun:
|
| t0 = time.perf_counter()
|
| instance = generate_instance(problem_type, size, seed, constraints, objectives)
|
| limit = time_limit or self.time_limit_sec
|
| engine = OptimizationEngine(limit)
|
| results = engine.solve_instance(instance)
|
| winner = self._pick_winner(results, problem_type)
|
| gap = self._winner_gap(results, winner, problem_type)
|
| return ExperimentRun(
|
| run_id=uuid.uuid4().hex[:12],
|
| instance=instance,
|
| model_version=ENGINE_VERSION,
|
| solver_id="multi",
|
| solver_config={"time_limit": limit},
|
| parameters={"size": size, "seed": seed, "problem_type": problem_type},
|
| results=results,
|
| winner=winner,
|
| winner_gap_pct=gap,
|
| runtime_sec=round(time.perf_counter() - t0, 4),
|
| )
|
|
|
| @staticmethod
|
| def _pick_winner(results: list[SolveResult], problem_type: str) -> str:
|
| feasible = [r for r in results if r.metrics.feasible]
|
| if not feasible:
|
| return results[0].method_id if results else "none"
|
| minimize = PROBLEM_TYPES.get(problem_type, {}).get("objective") == "minimize"
|
| if minimize:
|
| best = min(feasible, key=lambda r: (r.metrics.objective_value, r.metrics.elapsed_time_sec))
|
| else:
|
| best = max(feasible, key=lambda r: (r.metrics.objective_value, -r.metrics.elapsed_time_sec))
|
| return best.method_id
|
|
|
| @staticmethod
|
| def _winner_gap(results: list[SolveResult], winner: str, problem_type: str) -> float:
|
| winner_r = next((r for r in results if r.method_id == winner), None)
|
| if not winner_r or not winner_r.metrics.feasible:
|
| return 0.0
|
| others = [r for r in results if r.method_id != winner and r.metrics.feasible]
|
| if not others:
|
| return 0.0
|
| gaps = []
|
| for r in others:
|
| if winner_r.metrics.objective_value > 0:
|
| gaps.append(
|
| abs(r.metrics.objective_value - winner_r.metrics.objective_value)
|
| / winner_r.metrics.objective_value * 100
|
| )
|
| return round(sum(gaps) / len(gaps), 2) if gaps else 0.0
|
|
|
