| """Exact and reference solvers for OracleMem memory writing."""
|
|
|
| from __future__ import annotations
|
|
|
| from dataclasses import replace
|
|
|
| from .objective import (
|
| candidate_cost,
|
| candidate_coverage,
|
| candidate_id,
|
| candidate_maps,
|
| coverage_utility,
|
| experience_id,
|
| marginal_gain,
|
| selected_cost,
|
| unit_weights,
|
| )
|
| from .schema import CandidateMemory, Instance, SolverResult
|
|
|
|
|
| def is_feasible(candidates: list[CandidateMemory], budget: int) -> bool:
|
| if selected_cost(candidates) > budget:
|
| return False
|
| groups = [experience_id(candidate) for candidate in candidates]
|
| return len(groups) == len(set(groups))
|
|
|
|
|
| def _result(method: str, budget: int, selected: list[CandidateMemory], weights: dict[str, float]) -> SolverResult:
|
| return SolverResult(
|
| method=method,
|
| budget=budget,
|
| selected_ids=tuple(candidate_id(candidate) for candidate in selected),
|
| utility=coverage_utility(selected, weights),
|
| cost=selected_cost(selected),
|
| )
|
|
|
|
|
| def exact_bruteforce(instance: Instance, budget: int, method: str = "exact_opt") -> SolverResult:
|
| """Exact search by enumerating one representation or discard per experience."""
|
| weights = unit_weights(instance)
|
| _, by_exp = candidate_maps(instance)
|
| exp_ids = [experience.experience_id for experience in instance.experiences]
|
| best: list[CandidateMemory] = []
|
| best_utility = -1.0
|
|
|
| def dfs(index: int, selected: list[CandidateMemory], cost: int) -> None:
|
| nonlocal best, best_utility
|
| if cost > budget:
|
| return
|
| if index == len(exp_ids):
|
| utility = coverage_utility(selected, weights)
|
| if utility > best_utility:
|
| best_utility = utility
|
| best = list(selected)
|
| return
|
| exp_id = exp_ids[index]
|
| dfs(index + 1, selected, cost)
|
| for candidate in by_exp.get(exp_id, []):
|
| candidate_storage = candidate_cost(candidate)
|
| if cost + candidate_storage <= budget:
|
| selected.append(candidate)
|
| dfs(index + 1, selected, cost + candidate_storage)
|
| selected.pop()
|
|
|
| dfs(0, [], 0)
|
| return _result(method, budget, best, weights)
|
|
|
|
|
| def exact_branch_and_bound(instance: Instance, budget: int) -> SolverResult:
|
| """Exact DFS with a simple admissible remaining-unit upper bound."""
|
| weights = unit_weights(instance)
|
| _, by_exp = candidate_maps(instance)
|
| exp_ids = [experience.experience_id for experience in instance.experiences]
|
| suffix_units: list[set[str]] = [set() for _ in range(len(exp_ids) + 1)]
|
| for index in range(len(exp_ids) - 1, -1, -1):
|
| units = set(suffix_units[index + 1])
|
| for candidate in by_exp.get(exp_ids[index], []):
|
| units.update(unit for unit, value in candidate_coverage(candidate).items() if value > 0)
|
| suffix_units[index] = units
|
|
|
| best: list[CandidateMemory] = []
|
| best_utility = -1.0
|
|
|
| def dfs(index: int, selected: list[CandidateMemory], cost: int) -> None:
|
| nonlocal best, best_utility
|
| if cost > budget:
|
| return
|
| current_utility = coverage_utility(selected, weights)
|
| optimistic = current_utility + sum(weights.get(unit, 0.0) for unit in suffix_units[index])
|
| if optimistic + 1e-12 < best_utility:
|
| return
|
| if index == len(exp_ids):
|
| if current_utility > best_utility:
|
| best_utility = current_utility
|
| best = list(selected)
|
| return
|
| exp_id = exp_ids[index]
|
| choices = sorted(
|
| by_exp.get(exp_id, []),
|
| key=lambda candidate: (
|
| sum(weights.get(unit, 0.0) for unit in candidate_coverage(candidate)) /
|
| max(candidate_cost(candidate), 1)
|
| ),
|
| reverse=True,
|
| )
|
| for candidate in choices:
|
| candidate_storage = candidate_cost(candidate)
|
| if cost + candidate_storage <= budget:
|
| selected.append(candidate)
|
| dfs(index + 1, selected, cost + candidate_storage)
|
| selected.pop()
|
| dfs(index + 1, selected, cost)
|
|
|
| dfs(0, [], 0)
|
| return _result("exact_branch_bound", budget, best, weights)
|
|
|
|
|
| def attach_ratio(result: SolverResult, optimum: SolverResult, basis: str = "opt_exact") -> SolverResult:
|
| ratio = result.utility / optimum.utility if optimum.utility > 0 else 1.0
|
| return replace(result, ratio=ratio, ratio_basis=basis)
|
|
|
|
|
| def greedy_reference(instance: Instance, budget: int, method: str = "greedy_reference") -> SolverResult:
|
| """Offline greedy reference by marginal utility density.
|
|
|
| This is a reference denominator/baseline, not an exact optimum. It enforces
|
| both the storage budget and the one-candidate-per-experience constraint.
|
| """
|
| weights = unit_weights(instance)
|
| remaining = list(instance.candidates)
|
| selected: list[CandidateMemory] = []
|
| used_exp: set[str] = set()
|
| cost = 0
|
| while True:
|
| best = None
|
| best_key = (0.0, 0.0, "")
|
| for candidate in remaining:
|
| exp_id = experience_id(candidate)
|
| candidate_storage = candidate_cost(candidate)
|
| if exp_id in used_exp or cost + candidate_storage > budget:
|
| continue
|
| gain = marginal_gain(selected, candidate, weights)
|
| if gain <= 0:
|
| continue
|
| density = gain / max(candidate_storage, 1)
|
| key = (density, gain, candidate_id(candidate))
|
| if key > best_key:
|
| best_key = key
|
| best = candidate
|
| if best is None:
|
| break
|
| selected.append(best)
|
| used_exp.add(experience_id(best))
|
| cost += candidate_cost(best)
|
| remaining.remove(best)
|
| return _result(method, budget, selected, weights)
|
|
|
|
|
|
|
| brute_force_exact = exact_bruteforce
|
| branch_and_bound_exact = exact_branch_and_bound
|
| solve_bruteforce_exact = exact_bruteforce
|
| solve_exact_bruteforce = exact_bruteforce
|
| solve_branch_and_bound_exact = exact_branch_and_bound
|
| solve_exact_branch_and_bound = exact_branch_and_bound
|
| solve_greedy_reference = greedy_reference
|
|
|
