| from __future__ import annotations |
|
|
| import time |
| from dataclasses import dataclass |
|
|
| from ortools.sat.python import cp_model |
|
|
| from src.domain import ( |
| AssignmentInstance, |
| AssignmentRow, |
| Family, |
| InventoryInstance, |
| InventoryOrder, |
| ScheduleInstance, |
| ScheduleStart, |
| Solution, |
| SolveStatus, |
| parse_instance, |
| ) |
|
|
|
|
| @dataclass |
| class SolverOutcome: |
| solution: Solution |
| seconds: float |
| solver_name: str |
| message: str |
|
|
|
|
| def _status(model_status: int) -> SolveStatus: |
| if model_status == cp_model.OPTIMAL: |
| return SolveStatus.OPTIMAL |
| if model_status == cp_model.FEASIBLE: |
| return SolveStatus.FEASIBLE |
| if model_status == cp_model.INFEASIBLE: |
| return SolveStatus.INFEASIBLE |
| if model_status in {cp_model.UNKNOWN, cp_model.MODEL_INVALID}: |
| return SolveStatus.TIMEOUT |
| return SolveStatus.ERROR |
|
|
|
|
| def _status_name(model_status: int) -> str: |
| names = { |
| cp_model.OPTIMAL: "OPTIMAL", |
| cp_model.FEASIBLE: "FEASIBLE", |
| cp_model.INFEASIBLE: "INFEASIBLE", |
| cp_model.UNKNOWN: "UNKNOWN", |
| cp_model.MODEL_INVALID: "MODEL_INVALID", |
| } |
| return names.get(model_status, str(model_status)) |
|
|
|
|
| def solve_inventory(instance: InventoryInstance, seconds: float, threads: int = 1) -> SolverOutcome: |
| started = time.perf_counter() |
| model = cp_model.CpModel() |
| periods = instance.periods |
| skus = instance.skus |
| order: dict[tuple[str, int], cp_model.IntVar] = {} |
| inv: dict[tuple[str, int], cp_model.IntVar] = {} |
| short: dict[tuple[str, int], cp_model.IntVar] = {} |
| sold: dict[tuple[str, int], cp_model.IntVar] = {} |
|
|
| max_demand = max((max(sku.demand) for sku in skus), default=1) |
| max_pack = max((sku.pack_size for sku in skus), default=1) |
| max_order = max(max_demand * periods + max_pack * 4, 1) |
|
|
| for sku in skus: |
| for t in range(1, periods + 1): |
| packs = model.NewIntVar(0, max_order // sku.pack_size + 1, f"packs_{sku.sku_id}_{t}") |
| qty = model.NewIntVar(0, max_order, f"ord_{sku.sku_id}_{t}") |
| model.Add(qty == packs * sku.pack_size) |
| order[(sku.sku_id, t)] = qty |
| inv[(sku.sku_id, t)] = model.NewIntVar(0, instance.warehouse_capacity, f"inv_{sku.sku_id}_{t}") |
| demand = int(sku.demand[t - 1]) |
| short[(sku.sku_id, t)] = model.NewIntVar(0, demand, f"sh_{sku.sku_id}_{t}") |
| sold[(sku.sku_id, t)] = model.NewIntVar(0, demand, f"sd_{sku.sku_id}_{t}") |
| prev = sku.initial_stock if t == 1 else inv[(sku.sku_id, t - 1)] |
| model.Add(inv[(sku.sku_id, t)] + sold[(sku.sku_id, t)] == prev + qty) |
| model.Add(sold[(sku.sku_id, t)] + short[(sku.sku_id, t)] == demand) |
| if instance.cover_required: |
| model.Add(short[(sku.sku_id, t)] == 0) |
|
|
| for t in range(1, periods + 1): |
| model.Add(sum(inv[(sku.sku_id, t)] for sku in skus) <= instance.warehouse_capacity) |
|
|
| model.Add( |
| sum(sku.unit_cost * order[(sku.sku_id, t)] for sku in skus for t in range(1, periods + 1)) <= instance.budget |
| ) |
|
|
| objective = [] |
| for sku in skus: |
| for t in range(1, periods + 1): |
| objective.append(sku.unit_cost * order[(sku.sku_id, t)]) |
| objective.append(sku.holding_cost * inv[(sku.sku_id, t)]) |
| objective.append(sku.shortage_cost * short[(sku.sku_id, t)]) |
| model.Minimize(sum(objective)) |
|
|
| solver = cp_model.CpSolver() |
| solver.parameters.max_time_in_seconds = float(seconds) |
| solver.parameters.num_search_workers = int(threads) |
| raw = solver.Solve(model) |
| status = _status(raw) |
| elapsed = time.perf_counter() - started |
| message = _status_name(raw) |
| if status in {SolveStatus.OPTIMAL, SolveStatus.FEASIBLE}: |
| orders = [ |
| InventoryOrder(sku_id=sku.sku_id, period=t, qty=int(solver.Value(order[(sku.sku_id, t)]))) |
| for sku in skus |
| for t in range(1, periods + 1) |
| ] |
| obj = float(solver.ObjectiveValue()) |
| bound = float(solver.BestObjectiveBound()) if status == SolveStatus.FEASIBLE else obj |
| return SolverOutcome( |
| Solution( |
| family=Family.INVENTORY, |
| status=status, |
| objective=obj, |
| bound=bound, |
| orders=orders, |
| message=message, |
| ), |
| elapsed, |
| "ortools-cpsat", |
| message, |
| ) |
| return SolverOutcome( |
| Solution(family=Family.INVENTORY, status=status, message=message), |
| elapsed, |
| "ortools-cpsat", |
| message, |
| ) |
|
|
|
|
| def solve_assignment(instance: AssignmentInstance, seconds: float, threads: int = 1) -> SolverOutcome: |
| started = time.perf_counter() |
| model = cp_model.CpModel() |
| x: dict[tuple[str, str], cp_model.IntVar] = {} |
| costs = instance.cost_map() |
| for task in instance.tasks: |
| for agent in instance.agents: |
| if instance.eligible(task, agent) and (task.task_id, agent.agent_id) in costs: |
| x[(task.task_id, agent.agent_id)] = model.NewBoolVar(f"x_{task.task_id}_{agent.agent_id}") |
|
|
| unassigned: dict[str, cp_model.IntVar] = {} |
| for task in instance.tasks: |
| assigned = [x[(task.task_id, agent.agent_id)] for agent in instance.agents if (task.task_id, agent.agent_id) in x] |
| miss = model.NewBoolVar(f"u_{task.task_id}") |
| unassigned[task.task_id] = miss |
| model.Add(sum(assigned) + miss == 1) |
| if task.required: |
| model.Add(miss == 0) |
|
|
| for agent in instance.agents: |
| load = [ |
| task.size * x[(task.task_id, agent.agent_id)] |
| for task in instance.tasks |
| if (task.task_id, agent.agent_id) in x |
| ] |
| if load: |
| model.Add(sum(load) <= agent.capacity) |
|
|
| obj_terms = [] |
| for (task_id, agent_id), var in x.items(): |
| obj_terms.append(costs[(task_id, agent_id)] * var) |
| for task in instance.tasks: |
| obj_terms.append(task.penalty * unassigned[task.task_id]) |
| model.Minimize(sum(obj_terms) if obj_terms else 0) |
|
|
| solver = cp_model.CpSolver() |
| solver.parameters.max_time_in_seconds = float(seconds) |
| solver.parameters.num_search_workers = int(threads) |
| raw = solver.Solve(model) |
| status = _status(raw) |
| elapsed = time.perf_counter() - started |
| message = _status_name(raw) |
| if status in {SolveStatus.OPTIMAL, SolveStatus.FEASIBLE}: |
| rows = [ |
| AssignmentRow(task_id=task_id, agent_id=agent_id) |
| for (task_id, agent_id), var in x.items() |
| if solver.Value(var) |
| ] |
| leftover = [task_id for task_id, var in unassigned.items() if solver.Value(var)] |
| obj = float(solver.ObjectiveValue()) |
| bound = float(solver.BestObjectiveBound()) if status == SolveStatus.FEASIBLE else obj |
| return SolverOutcome( |
| Solution( |
| family=Family.ASSIGNMENT, |
| status=status, |
| objective=obj, |
| bound=bound, |
| assignments=rows, |
| unassigned=leftover, |
| message=message, |
| ), |
| elapsed, |
| "ortools-cpsat", |
| message, |
| ) |
| return SolverOutcome( |
| Solution(family=Family.ASSIGNMENT, status=status, message=message), |
| elapsed, |
| "ortools-cpsat", |
| message, |
| ) |
|
|
|
|
| def solve_scheduling(instance: ScheduleInstance, seconds: float, threads: int = 1) -> SolverOutcome: |
| started = time.perf_counter() |
| model = cp_model.CpModel() |
| horizon = max(instance.horizon, sum(job.duration for job in instance.jobs) + max((job.release for job in instance.jobs), default=0) + 2) |
| intervals_by_machine: dict[str, list] = {machine: [] for machine in instance.machines} |
| start: dict[str, cp_model.IntVar] = {} |
| end: dict[str, cp_model.IntVar] = {} |
| tardy: dict[str, cp_model.IntVar] = {} |
| assign: dict[tuple[str, str], cp_model.IntVar] = {} |
|
|
| for job in instance.jobs: |
| start[job.job_id] = model.NewIntVar(job.release, horizon, f"s_{job.job_id}") |
| end[job.job_id] = model.NewIntVar(job.release + job.duration, horizon + job.duration, f"e_{job.job_id}") |
| model.Add(end[job.job_id] == start[job.job_id] + job.duration) |
| tardy[job.job_id] = model.NewIntVar(0, horizon + job.duration, f"tard_{job.job_id}") |
| model.Add(tardy[job.job_id] >= end[job.job_id] - job.due) |
| if job.hard_due: |
| model.Add(end[job.job_id] <= job.due) |
| eligible = [machine for machine in instance.machines if machine in set(job.machine_eligible)] |
| if not eligible: |
| eligible = list(instance.machines) |
| machine_bools = [] |
| for machine in eligible: |
| flag = model.NewBoolVar(f"m_{job.job_id}_{machine}") |
| assign[(job.job_id, machine)] = flag |
| interval = model.NewOptionalIntervalVar(start[job.job_id], job.duration, end[job.job_id], flag, f"iv_{job.job_id}_{machine}") |
| intervals_by_machine[machine].append(interval) |
| machine_bools.append(flag) |
| model.AddExactlyOne(machine_bools) |
|
|
| for machine, intervals in intervals_by_machine.items(): |
| if intervals: |
| model.AddNoOverlap(intervals) |
|
|
| job_ids = {job.job_id for job in instance.jobs} |
| for edge in instance.precedences: |
| if edge.before in job_ids and edge.after in job_ids: |
| model.Add(end[edge.before] <= start[edge.after]) |
|
|
| makespan = model.NewIntVar(0, horizon + 8, "makespan") |
| for job in instance.jobs: |
| model.Add(makespan >= end[job.job_id]) |
| model.Minimize(sum(job.weight * tardy[job.job_id] for job in instance.jobs) * 100 + makespan) |
|
|
| solver = cp_model.CpSolver() |
| solver.parameters.max_time_in_seconds = float(seconds) |
| solver.parameters.num_search_workers = int(threads) |
| raw = solver.Solve(model) |
| status = _status(raw) |
| elapsed = time.perf_counter() - started |
| message = _status_name(raw) |
| if status in {SolveStatus.OPTIMAL, SolveStatus.FEASIBLE}: |
| starts = [] |
| for job in instance.jobs: |
| machine_id = next(machine for machine in instance.machines if (job.job_id, machine) in assign and solver.Value(assign[(job.job_id, machine)])) |
| starts.append( |
| ScheduleStart( |
| job_id=job.job_id, |
| machine_id=machine_id, |
| start=int(solver.Value(start[job.job_id])), |
| end=int(solver.Value(end[job.job_id])), |
| ) |
| ) |
| weighted = sum(job.weight * max(0, int(solver.Value(end[job.job_id])) - job.due) for job in instance.jobs) |
| obj = float(weighted) |
| return SolverOutcome( |
| Solution( |
| family=Family.SCHEDULING, |
| status=status, |
| objective=obj, |
| bound=obj if status == SolveStatus.OPTIMAL else None, |
| starts=starts, |
| message=message, |
| ), |
| elapsed, |
| "ortools-cpsat", |
| message, |
| ) |
| return SolverOutcome( |
| Solution(family=Family.SCHEDULING, status=status, message=message), |
| elapsed, |
| "ortools-cpsat", |
| message, |
| ) |
|
|
|
|
| def solve_instance(family: Family | str, payload: dict, seconds: float, threads: int = 1) -> SolverOutcome: |
| family = Family(family) |
| instance = parse_instance(family, payload) |
| if family == Family.INVENTORY: |
| return solve_inventory(instance, seconds, threads) |
| if family == Family.ASSIGNMENT: |
| return solve_assignment(instance, seconds, threads) |
| return solve_scheduling(instance, seconds, threads) |
|
|
