File size: 4,273 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 | """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
|