File size: 2,277 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
"""Experiment manager — tracks runs with full provenance."""

from __future__ import annotations

import json
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

from optos.constants import ENGINE_VERSION
from optos.engine import OptimizationEngine
from optos.models import ExperimentRun


class ExperimentManager:
    def __init__(self, time_limit_sec: float = 15.0) -> None:
        self.engine = OptimizationEngine(time_limit_sec)
        self._history: list[ExperimentRun] = []

    def run(

        self,

        problem_type: str,

        size: str = "medium",

        seed: int = 42,

        time_limit: float | None = None,

        constraints: dict[str, Any] | None = None,

        objectives: dict[str, Any] | None = None,

    ) -> ExperimentRun:
        experiment = self.engine.run_experiment(
            problem_type, size, seed, time_limit, constraints, objectives,
        )
        self._history.append(experiment)
        return experiment

    def history(self) -> list[ExperimentRun]:
        return list(self._history)

    def export_run(self, run: ExperimentRun) -> dict[str, Any]:
        return {
            "exported_at": datetime.now(timezone.utc).isoformat(),
            "engine_version": ENGINE_VERSION,
            "run": run.to_dict(),
        }

    def save_run(self, run: ExperimentRun, path: Path) -> None:
        path.write_text(json.dumps(self.export_run(run), indent=2), encoding="utf-8")

    def summary_table(self) -> list[dict[str, Any]]:
        rows = []
        for run in self._history:
            for r in run.results:
                rows.append({
                    "run_id": run.run_id,
                    "problem_type": run.instance.problem_type,
                    "size": run.instance.size,
                    "method": r.method_label,
                    "category": r.method_category,
                    "objective": r.metrics.objective_value,
                    "gap_pct": r.metrics.optimality_gap,
                    "time_sec": r.metrics.elapsed_time_sec,
                    "feasible": r.metrics.feasible,
                    "winner": r.method_id == run.winner,
                })
        return rows