Download scheduling.py from vynly/nnai-bench: direct link, hf CLI and curl.
- Browser
- Download file 16.7 kB
-
https://huggingface.co/datasets/vynly/nnai-bench/resolve/main/scheduling.py
- Command line
-
hf download hf://datasets/vynly/nnai-bench/scheduling.py
-
curl -L -o scheduling.py https://huggingface.co/datasets/vynly/nnai-bench/resolve/main/scheduling.py
16.7 kB
| """NNAI scheduling v0.2: planted-feasible shift CSPs and diagnostic scoring. | |
| Standard library only. Scores measure validity, not match to a reference schedule. | |
| The frozen v0.1 multiple-choice suite is a separate benchmark. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| from collections import Counter | |
| import hashlib | |
| from itertools import combinations | |
| import json | |
| from pathlib import Path | |
| import random | |
| from benchmark import ROOT, DATASET, ARTIFACTS, dump, read_rows, write_rows | |
| VERSION = "nnai-scheduling-0.2" | |
| FAMILIES = ("staffing", "availability", "skills", "no_overlap", "rest", "workload", "incompatibility") | |
| SIZES = {"train": 120, "validation": 60, "test": 120} | |
| def validate_predictions(predictions, questions): | |
| if not isinstance(predictions, list): | |
| raise ValueError("Scheduling predictions must be an array of {id, assignments} objects") | |
| expected = {q["id"]: q for q in questions} | |
| result = {} | |
| for p in predictions: | |
| if not isinstance(p, dict) or set(p) != {"id", "assignments"}: | |
| raise ValueError("Each schedule must contain exactly id and assignments") | |
| ident = p["id"] | |
| if not isinstance(ident, str) or ident not in expected or ident in result: | |
| raise ValueError("Unknown or duplicate scheduling ID") | |
| q = expected[ident] | |
| shifts = {s["id"] for s in q["shifts"]} | |
| workers = {w["id"] for w in q["workers"]} | |
| assignments = p["assignments"] | |
| if not isinstance(assignments, list) or len(assignments) != len(shifts): | |
| raise ValueError("Include every shift exactly once; use worker_ids: [] for an unfilled shift") | |
| mapping = {} | |
| for a in assignments: | |
| if not isinstance(a, dict) or set(a) != {"shift_id", "worker_ids"}: | |
| raise ValueError("Each assignment must contain exactly shift_id and worker_ids") | |
| sid, ids = a["shift_id"], a["worker_ids"] | |
| if not isinstance(sid, str) or sid not in shifts or sid in mapping: | |
| raise ValueError("Unknown or duplicate shift ID") | |
| if not isinstance(ids, list) or any(not isinstance(w, str) or w not in workers for w in ids): | |
| raise ValueError("Unknown worker ID or invalid worker_ids list") | |
| if len(set(ids)) != len(ids): | |
| raise ValueError("A worker cannot be listed twice in the same shift") | |
| mapping[sid] = ids | |
| result[ident] = mapping | |
| if set(result) != set(expected): | |
| raise ValueError(f"Expected {len(expected)} unique scheduling IDs, received {len(result)}") | |
| return result | |
| def check_case(q, assignments): | |
| """Evaluate each instantiated constraint, with stable diagnostic identifiers.""" | |
| checks = {f: [] for f in FAMILIES} | |
| shifts = {s["id"]: s for s in q["shifts"]} | |
| workers = {w["id"]: w for w in q["workers"]} | |
| by_worker = {wid: [] for wid in workers} | |
| def add(family, key, ok, expected, actual): | |
| checks[family].append({"constraint_id": key, "passed": bool(ok), "expected": expected, "actual": actual}) | |
| for sid, s in shifts.items(): | |
| ids = assignments[sid] | |
| add("staffing", f"staffing:{sid}", len(ids) == s["required_workers"], s["required_workers"], len(ids)) | |
| for wid in ids: | |
| w = workers[wid] | |
| by_worker[wid].append(s) | |
| add("availability", f"availability:{sid}:{wid}", sid not in w["unavailable"], "available", "unavailable" if sid in w["unavailable"] else "available") | |
| add("skills", f"skills:{sid}:{wid}", s["required_skill"] in w["skills"], s["required_skill"], w["skills"]) | |
| for a, b in q["incompatible_pairs"]: | |
| add("incompatibility", f"incompatibility:{sid}:{a}:{b}", not (a in ids and b in ids), "not on same shift", [w for w in (a, b) if w in ids]) | |
| for wid, schedule in by_worker.items(): | |
| w = workers[wid] | |
| ordered = sorted(schedule, key=lambda s: (s["start"], s["id"])) | |
| hours = sum(s["end"] - s["start"] for s in ordered) | |
| add("workload", f"min_shifts:{wid}", len(ordered) >= w["min_shifts"], w["min_shifts"], len(ordered)) | |
| add("workload", f"max_shifts:{wid}", len(ordered) <= w["max_shifts"], w["max_shifts"], len(ordered)) | |
| add("workload", f"max_hours:{wid}", hours <= w["max_hours"], w["max_hours"], hours) | |
| for first, second in combinations(ordered, 2): | |
| gap = second["start"] - first["end"] | |
| add("no_overlap", f"overlap:{wid}:{first['id']}:{second['id']}", gap >= 0, ">=0 hours gap", gap) | |
| add("rest", f"rest:{wid}:{first['id']}:{second['id']}", gap >= q["min_rest_hours"], q["min_rest_hours"], gap) | |
| family_report = {} | |
| violations = [] | |
| for family, items in checks.items(): | |
| passed = sum(c["passed"] for c in items) | |
| family_report[family] = {"passed": passed, "total": len(items), "satisfaction": 100 * passed / len(items) if items else 100.0} | |
| violations.extend({"family": family, **c} for c in items if not c["passed"]) | |
| demand = sum(s["required_workers"] for s in shifts.values()) | |
| filled = sum(min(len(assignments[sid]), s["required_workers"]) for sid, s in shifts.items()) | |
| coverage = filled / demand | |
| raw = sum(c["satisfaction"] for c in family_report.values()) / len(FAMILIES) | |
| return {"id": q["id"], "difficulty": q["difficulty"], "feasible": not violations, | |
| "coverage": 100 * coverage, "raw_constraint_satisfaction": raw, | |
| "partial_score": raw * coverage, "families": family_report, "violations": violations} | |
| def score_schedules(predictions, questions): | |
| mappings = validate_predictions(predictions, questions) | |
| cases = [check_case(q, mappings[q["id"]]) for q in questions] | |
| if not cases: | |
| raise ValueError("Cannot score an empty benchmark") | |
| def mean(key, subset=cases): | |
| return sum(c[key] for c in subset) / len(subset) | |
| families = {} | |
| for f in FAMILIES: | |
| families[f] = {"mean_satisfaction": sum(c["families"][f]["satisfaction"] for c in cases) / len(cases), | |
| "passed": sum(c["families"][f]["passed"] for c in cases), | |
| "total": sum(c["families"][f]["total"] for c in cases), | |
| "violations": sum(c["families"][f]["total"] - c["families"][f]["passed"] for c in cases)} | |
| tiers = {} | |
| for tier in sorted({c["difficulty"] for c in cases}): | |
| subset = [c for c in cases if c["difficulty"] == tier] | |
| tiers[str(tier)] = {"total": len(subset), "feasible_rate": 100 * mean("feasible", subset), "partial_score": mean("partial_score", subset)} | |
| return {"benchmark_version": VERSION, "total": len(cases), "feasible_count": sum(c["feasible"] for c in cases), | |
| "feasible_rate": 100 * mean("feasible"), "partial_score": mean("partial_score"), | |
| "raw_constraint_satisfaction": mean("raw_constraint_satisfaction"), "coverage": mean("coverage"), | |
| "families": families, "tiers": tiers, "cases": cases} | |
| def compatible(q, s, wid, allocated): | |
| w = next(w for w in q["workers"] if w["id"] == wid) | |
| if s["id"] in w["unavailable"] or s["required_skill"] not in w["skills"]: | |
| return False | |
| old = allocated[wid] | |
| if len(old) >= w["max_shifts"] or sum(x["end"] - x["start"] for x in old) + s["end"] - s["start"] > w["max_hours"]: | |
| return False | |
| return all(s["start"] - x["end"] >= q["min_rest_hours"] or x["start"] - s["end"] >= q["min_rest_hours"] for x in old) | |
| def solve(q, max_nodes=20000): | |
| """Bounded backtracking with MRV and minimum-workload forward checking. | |
| Receives only question fields. Exhausting the node budget returns an empty | |
| schedule, never a claim of unsatisfiability. No reference witness is read. | |
| """ | |
| workers = {w["id"]: w for w in q["workers"]} | |
| allocated = {wid: [] for wid in workers} | |
| result, nodes = {}, 0 | |
| forbidden = {frozenset(p) for p in q["incompatible_pairs"]} | |
| def domain(s): | |
| candidates = [wid for wid in workers if compatible(q, s, wid, allocated)] | |
| combos = [c for c in combinations(candidates, s["required_workers"]) if all(frozenset(p) not in forbidden for p in combinations(c, 2))] | |
| return sorted(combos, key=lambda c: (-sum(max(0, workers[w]["min_shifts"] - len(allocated[w])) for w in c), sum(len(allocated[w]) for w in c), c)) | |
| def search(remaining): | |
| nonlocal nodes | |
| nodes += 1 | |
| if nodes > max_nodes: | |
| return False | |
| if not remaining: | |
| return all(len(allocated[wid]) >= w["min_shifts"] for wid, w in workers.items()) | |
| for wid, w in workers.items(): | |
| if len(allocated[wid]) + sum(compatible(q, s, wid, allocated) for s in remaining) < w["min_shifts"]: | |
| return False | |
| domains = [(s, domain(s)) for s in remaining] | |
| s, options = min(domains, key=lambda pair: (len(pair[1]), pair[0]["start"], pair[0]["id"])) | |
| rest = [x for x in remaining if x["id"] != s["id"]] | |
| for ids in options: | |
| result[s["id"]] = list(ids) | |
| for wid in ids: allocated[wid].append(s) | |
| if search(rest): return True | |
| for wid in ids: allocated[wid].pop() | |
| result.pop(s["id"], None) | |
| if nodes > max_nodes: break | |
| return False | |
| found = search(q["shifts"]) | |
| return {"id": q["id"], "assignments": [{"shift_id": s["id"], "worker_ids": result[s["id"]] if found else []} for s in q["shifts"]]}, {"nodes": nodes, "found": found, "budget_exhausted": nodes > max_nodes} | |
| def greedy(q): | |
| """Chronological, low-load greedy baseline with no backtracking.""" | |
| allocated = {w["id"]: [] for w in q["workers"]} | |
| result = [] | |
| forbidden = {frozenset(p) for p in q["incompatible_pairs"]} | |
| for s in sorted(q["shifts"], key=lambda s: (s["start"], s["id"])): | |
| chosen = [] | |
| for wid in sorted(allocated, key=lambda w: (len(allocated[w]), w)): | |
| if compatible(q, s, wid, allocated) and all(frozenset((wid, x)) not in forbidden for x in chosen): | |
| chosen.append(wid) | |
| allocated[wid].append(s) | |
| if len(chosen) == s["required_workers"]: break | |
| result.append({"shift_id": s["id"], "worker_ids": chosen}) | |
| return {"id": q["id"], "assignments": result} | |
| def make_case(split, i, rng): | |
| tier = i % 3 + 1 | |
| count, days, per_day = ((5, 3, 2), (7, 5, 2), (10, 7, 3))[tier - 1] | |
| tag = f"{split[0]}{rng.getrandbits(32):08x}" | |
| skills = ["general"] if tier == 1 else ["care", "technical", "logistics"] | |
| while True: | |
| workers = [{"id": f"w_{tag}_{j}", "skills": skills[:] if tier == 1 else rng.sample(skills, rng.randint(1, 3)), | |
| "unavailable": [], "min_shifts": 0, "max_shifts": 100, "max_hours": 800} for j in range(count)] | |
| shifts = [{"id": f"d{d}_s{s}", "start": d * 24 + (8 if per_day == 2 else 0) + s * 8, | |
| "end": d * 24 + (8 if per_day == 2 else 0) + s * 8 + 8, | |
| "required_skill": rng.choice(skills), "required_workers": 1 if tier == 1 else rng.choice((1, 2, 2))} | |
| for d in range(days) for s in range(per_day)] | |
| pairs = [list(p) for p in rng.sample(list(combinations([w["id"] for w in workers], 2)), tier - 1)] | |
| q = {"id": f"scheduling-v02-{split}-{i:04d}", "benchmark_version": VERSION, "split": split, "difficulty": tier, | |
| "prompt": "Assign workers to every shift. Respect exact staffing, required skills, availability, non-overlap, minimum rest, each worker's min/max shifts and max hours, and incompatible pairs. Times are integer hours from day 0; intervals are half-open. Return shift_id and worker_ids for every shift.", | |
| "workers": workers, "shifts": shifts, "min_rest_hours": 8 if tier == 1 else 12, "incompatible_pairs": pairs} | |
| # Plant a feasible assignment first, then tighten limits/unavailability. | |
| allocated = {w["id"]: [] for w in workers} | |
| planted = [] | |
| forbidden = {frozenset(p) for p in pairs} | |
| for s in shifts: | |
| choices = [w["id"] for w in workers if compatible(q, s, w["id"], allocated)] | |
| rng.shuffle(choices) | |
| choices.sort(key=lambda wid: len(allocated[wid])) | |
| ids = [] | |
| for wid in choices: | |
| if all(frozenset((wid, other)) not in forbidden for other in ids): ids.append(wid) | |
| if len(ids) == s["required_workers"]: break | |
| if len(ids) < s["required_workers"]: break | |
| for wid in ids: allocated[wid].append(s) | |
| planted.append({"shift_id": s["id"], "worker_ids": ids}) | |
| if len(planted) == len(shifts): break | |
| for w in workers: | |
| used = {s["id"] for s in allocated[w["id"]]} | |
| w["min_shifts"] = max(0, len(used) - rng.randint(0, 1)) | |
| w["max_shifts"] = len(used) + rng.randint(0, 1) | |
| w["max_hours"] = 8 * (len(used) + rng.randint(0, 1)) | |
| w["unavailable"] = [s["id"] for s in shifts if s["id"] not in used and rng.random() < (.15, .25, .35)[tier - 1]] | |
| rng.shuffle(q["workers"]) | |
| rng.shuffle(q["shifts"]) | |
| return q, {"id": q["id"], "assignments": planted} | |
| def generate(): | |
| destination = DATASET / "scheduling_v02" | |
| witnesses = [] | |
| for k, (split, n) in enumerate(SIZES.items()): | |
| rng = random.Random(20261019 + k) | |
| rows = [] | |
| for i in range(n): | |
| q, witness = make_case(split, i, rng) | |
| assert score_schedules([witness], [q])["feasible_rate"] == 100 | |
| rows.append(q) | |
| witnesses.append(witness) | |
| write_rows(destination / f"{split}.jsonl", rows) | |
| if split == "test": | |
| dump(ARTIFACTS / "scheduling-test.json", rows) | |
| dump(destination / "example_predictions.json", [{"id": q["id"], "assignments": [{"shift_id": s["id"], "worker_ids": []} for s in q["shifts"]]} for q in rows]) | |
| dump(destination / "reference_witnesses.json", witnesses) | |
| manifest = {"benchmark_version": VERSION, "seed": 20261019, "split_sizes": SIZES, "families": FAMILIES, | |
| "sha256": {p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in sorted(destination.glob("*.json*")) if p.name != "manifest.json"}} | |
| dump(destination / "manifest.json", manifest) | |
| dump(ARTIFACTS / "scheduling-manifest.json", manifest) | |
| print("Generated", sum(SIZES.values()), "scheduling cases") | |
| def baselines(): | |
| questions = read_rows(DATASET / "scheduling_v02/test.jsonl") | |
| entries = [] | |
| for name, solver in (("greedy", greedy), ("bounded-backtracking", lambda q: solve(q)[0])): | |
| predictions = [solver(q) for q in questions] | |
| report = score_schedules(predictions, questions) | |
| dump(ARTIFACTS / f"scheduling-baselines/{name}.predictions.json", predictions) | |
| dump(ARTIFACTS / f"scheduling-baselines/{name}.report.json", report) | |
| summary = {k: v for k, v in report.items() if k != "cases"} | |
| entries.append({"id": name, "name": name.replace("-", " ").title(), "architecture": "symbolic search", "kind": "baseline", "status": "reproduced", "track": "closed-book", "training_provenance": "no neural training/data", "test_exposure": "template-informed baseline", "source_url": "https://huggingface.co/datasets/vynly/nnai-bench/blob/main/scheduling.py", "score": summary}) | |
| print(name, "feasible", round(report["feasible_rate"], 2), "partial", round(report["partial_score"], 2)) | |
| dump(ARTIFACTS / "scheduling-leaderboard.json", {"benchmark_version": VERSION, "entries": entries}) | |
| def main(): | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| sub = parser.add_subparsers(dest="command", required=True) | |
| sub.add_parser("generate") | |
| sub.add_parser("baselines") | |
| run = sub.add_parser("solve") | |
| run.add_argument("--questions", default=str(DATASET / "scheduling_v02/test.jsonl")) | |
| run.add_argument("--output", default="scheduling_predictions.json") | |
| run.add_argument("--max-nodes", type=int, default=20000) | |
| ev = sub.add_parser("score") | |
| ev.add_argument("predictions") | |
| ev.add_argument("--questions", default=str(DATASET / "scheduling_v02/test.jsonl")) | |
| ev.add_argument("--output") | |
| args = parser.parse_args() | |
| if args.command == "generate": generate() | |
| elif args.command == "baselines": baselines() | |
| elif args.command == "solve": | |
| dump(args.output, [solve(q, args.max_nodes)[0] for q in read_rows(args.questions)]) | |
| else: | |
| report = score_schedules(json.loads(Path(args.predictions).read_text(encoding="utf-8")), read_rows(args.questions)) | |
| if args.output: dump(args.output, report) | |
| print(json.dumps({k: v for k, v in report.items() if k != "cases"}, indent=2)) | |
| if __name__ == "__main__": main() | |