| """A task's reference: the proven optimum, the floor, the lazy policies' costs and rewards, and the real outcome. |
| |
| Nothing here is shown to the agent. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from pathlib import Path |
|
|
| from .baselines import POLICIES |
| from .check import evaluate |
| from .model import Task, plan_to_list |
| from .reward import score |
| from .solve import floor_parts, optimal_plan |
|
|
|
|
| def add_reference(task: Task, time_limit: float = 90.0, workers: int = 4, extend: int = 2) -> dict: |
| hints = {} |
| for name in ("greedy", "greedy_fast"): |
| try: |
| hints[name] = POLICIES[name](task) |
| except Exception as e: |
| hints[name] = None |
| task.reference.setdefault("errors", []).append(f"{name}: {type(e).__name__}: {e}") |
| best_hint = None |
| for name, p in hints.items(): |
| if p is None: |
| continue |
| r = evaluate(task, p) |
| if r.feasible and (best_hint is None or r.cost < best_hint[1]): |
| best_hint = (p, r.cost) |
| floor, parts = floor_parts(task) |
| sol = optimal_plan(task, time_limit=time_limit, workers=workers, hint=best_hint[0] if best_hint else None, |
| unit_floor=parts) |
| if sol.plan is None: |
| raise ValueError(f"{task.task_id}: no feasible plan found ({sol.status})") |
| floor = min(floor, sol.bound) |
| |
| limit, spent = time_limit, sol.seconds |
| for _ in range(extend): |
| gap = (sol.cost - sol.bound) / (sol.cost - floor + task.rule("gap_k")) |
| if sol.optimal or gap <= 0.01 or gap > 0.3: |
| break |
| limit *= 2 |
| nxt = optimal_plan(task, time_limit=limit, workers=workers, hint=sol.plan, unit_floor=parts) |
| spent += nxt.seconds |
| if nxt.plan is not None and (nxt.cost, -nxt.bound) <= (sol.cost, -sol.bound): |
| sol = nxt |
| elif nxt.plan is not None: |
| sol = type(sol)(sol.plan, sol.cost, max(sol.bound, nxt.bound), sol.optimal, sol.status, sol.seconds) |
| floor = min(floor, sol.bound) |
| ref = task.reference |
| ref.update(optimal_cost=sol.cost, optimal_plan=plan_to_list(sol.plan), proven_optimal=sol.optimal, |
| lower_bound=sol.bound, floor_cost=floor, solver_seconds=round(spent, 1), solver=sol.status) |
| score_baselines(task, hints) |
| if "real" in ref: |
| rr = ref["real"] |
| rew, _ = score(rr["cost"], True, 1.0, sol.cost, floor, gap_k) |
| rr["reward_if_legal"] = round(rew, 4) |
| return ref |
|
|
|
|
| def score_baselines(task: Task, hints: dict | None = None) -> None: |
| """The lazy policies' feasibility, cost, reward and rule breaks, against the stored optimum and floor.""" |
| ref = task.reference |
| if hints is None: |
| hints = {} |
| for name in ("greedy", "greedy_fast"): |
| try: |
| hints[name] = POLICIES[name](task) |
| except Exception as e: |
| hints[name] = None |
| ref.setdefault("errors", []).append(f"{name}: {type(e).__name__}: {e}") |
| gap_k = task.rule("gap_k") |
| for name, p in [("naive", POLICIES["naive"](task))] + list(hints.items()): |
| if p is None: |
| ref[f"{name}_feasible"] = False |
| ref[f"{name}_reward"] = 0.0 |
| continue |
| r = evaluate(task, p) |
| clean = sum(1 for x in r.runs if not x.problems) / max(1, len(r.runs)) |
| rew, _ = score(r.cost, r.feasible, clean, ref["optimal_cost"], ref["floor_cost"], gap_k) |
| ref[f"{name}_feasible"] = r.feasible |
| ref[f"{name}_cost"] = r.cost |
| ref[f"{name}_reward"] = round(rew, 4) |
| ref[f"{name}_violations"] = len(r.violations) |
|
|
|
|
| BASELINE_KEYS = [f"{n}_{k}" for n in ("naive", "greedy", "greedy_fast") for k in ("feasible", "cost", "reward", |
| "violations")] |
|
|
|
|
| def refresh_baselines(pack_dir: Path) -> list[str]: |
| """Re-score the lazy policies of every task in a pack (after a baseline fix), without re-solving. Rewrites the |
| pack only if something changed; returns the ids of the tasks that changed.""" |
| import json |
|
|
| from .build import write_pack |
| from .hardness import features |
| from .pack import _read |
|
|
| tasks, manifest = _read(pack_dir) |
| raw = [t.to_dict() for t in tasks] |
| changed = [] |
| for t, d in zip(tasks, raw): |
| before = {k: t.reference.get(k) for k in BASELINE_KEYS} |
| t.reference.pop("errors", None) |
| score_baselines(t) |
| if {k: t.reference.get(k) for k in BASELINE_KEYS} != before or "errors" in d["reference"]: |
| t.reference["hardness"] = features(t) |
| d["reference"] = t.reference |
| changed.append(t.task_id) |
| if changed: |
| log = [json.loads(x) for x in (pack_dir / "build_log.jsonl").read_text().splitlines()] |
| for st in log: |
| for t in tasks: |
| if st.get("task_id") == t.task_id and "hardness" in st: |
| st["hardness"] = t.reference["hardness"] |
| std = {"name", "split", "tasks", "file", "tiers", "sha256", "candidates", "days", "proven_optimal", "runs", |
| "source"} |
| write_pack(pack_dir, raw, log, manifest["split"], {k: v for k, v in manifest.items() if k not in std}) |
| return changed |
|
|
|
|
| if __name__ == "__main__": |
| import argparse |
|
|
| ap = argparse.ArgumentParser(description="re-score the lazy policies stored in task packs") |
| ap.add_argument("packs", nargs="+") |
| for pack in ap.parse_args().packs: |
| print(pack, refresh_baselines(Path(pack))) |
|
|
