| """Jev Rules-7: rule and policy decision tasks (evaluation only). Facts in the state, the policy RULE IN THE QUESTION, |
| gold computed exactly by code for the generated tasks; ShARC dev and the patent phrase test split are pinned public |
| sets. Skills: admission, rental, agent_rules, authority, fraud_points, sharc, patent_phrases, missing_facts (paired |
| complete / one-fact-removed records for the AUROC of the model's confidence). |
| """ |
|
|
| import gzip |
| import hashlib |
| import json |
| import random |
|
|
| import bench_common as X |
| from bench_common import choice, noul, noul_target, onehot, score as score_q |
|
|
| VERSION = "v1" |
| BENCH = "Rules7" |
| SKILLS = ("admission", "rental", "agent_rules", "authority", "fraud_points", "sharc", "patent_phrases", "missing_facts") |
| SIZES = {"admission": 400, "rental": 400, "agent_rules": 400, "authority": 400, "fraud_points": 400, "sharc": 400, |
| "patent_phrases": 400, "missing_facts": 160} |
| LICENSE = "CC0-1.0" |
| SHARC = ("tasksource/sharc", "fa4605de8281290c69af9dea6118b37d072c2b59", "data/validation-00000-of-00001.parquet") |
| PATENT = ("tasksource/patent-phrase-similarity", "ff1868796e44ac9ec02e870b447fde6c5bf2d6e4", |
| "data/test-00000-of-00001-c5556affccbcc71f.parquet") |
|
|
| NAMES = ["Alex Moreno", "Priya Raman", "Chen Wei", "Sara Lindqvist", "Tomasz Nowak", "Amara Okafor", "Lucas Ferreira", |
| "Yuki Tanaka", "Fatima Zahra", "Noah Becker", "Elena Petrova", "Diego Salazar", "Ines Costa", "Omar Haddad"] |
|
|
|
|
| def _item(id, skill, source, state, questions, targets, license=LICENSE, split="generated", **extra): |
| st = state if isinstance(state, str) else json.dumps(state, ensure_ascii=False) |
| key = st + " " + " ".join(q["instructions"] for q in questions.values()) |
| it = X._item(id, skill, source, st, questions, targets, license, key) |
| it.update(bench=BENCH, split=split, **extra) |
| return it |
|
|
|
|
| |
| class Cond: |
| """One condition on one fact: kind ge / le (numeric threshold t), bool, notbool, in (value in `opts`).""" |
|
|
| def __init__(s, spec: dict, rng: random.Random): |
| s.key, s.kind = spec["key"], spec["kind"] |
| s.spec = spec |
| s.t = rng.choice(spec["ts"]) if "ts" in spec else None |
| s.opts = spec.get("opts") |
| s.phrase = spec["phrase"].format(t=s.t) if "phrase" in spec else None |
| s.exc = spec.get("exc") |
|
|
| def test(s, v): |
| if s.kind == "ge": |
| return v >= s.t |
| if s.kind == "le": |
| return v <= s.t |
| if s.kind == "lt": |
| return v < s.t |
| if s.kind == "bool": |
| return bool(v) |
| if s.kind == "notbool": |
| return not v |
| return v in s.opts |
|
|
| def sample(s, rng: random.Random, truth: bool): |
| sp = s.spec |
| if s.kind in ("bool", "notbool"): |
| return truth if s.kind == "bool" else (not truth) |
| if s.kind == "in": |
| return rng.choice(s.opts if truth else sp["other"]) |
| if s.kind == "lt": |
| return max(sp["lo"], s.t - 1 - rng.choice([0, 0, 1, 2, 5])) if truth else s.t + rng.choice([0, 1, 3, 10, 60]) |
| step, dec = sp.get("step", 1), sp.get("dec", 0) |
| d = rng.choice([0, 1, 1, 2, 3, 5, 9]) * step |
| up = (s.kind == "ge") == truth |
| if not truth: |
| d = max(d, step) |
| v = s.t + d if up else s.t - d |
| v = min(sp["hi"], max(sp["lo"], v)) |
| v = round(v, dec) if dec else int(round(v)) |
| if s.test(v) != truth: |
| v = s.t if truth else (s.t - step if s.kind == "ge" else s.t + step) |
| v = round(v, dec) if dec else int(round(v)) |
| return v |
|
|
|
|
| def ev3(node, facts): |
| """Kleene evaluation: True / False / None (a needed fact is missing).""" |
| t = node[0] |
| if t == "c": |
| c = node[1] |
| return None if c.key not in facts else bool(c.test(facts[c.key])) |
| if t == "not": |
| v = ev3(node[1], facts) |
| return None if v is None else (not v) |
| vals = [ev3(n, facts) for n in node[1]] |
| if t == "and": |
| return False if False in vals else (None if None in vals else True) |
| return True if True in vals else (None if None in vals else False) |
|
|
|
|
| def conds_of(node): |
| if node[0] == "c": |
| return [node[1]] |
| if node[0] == "not": |
| return conds_of(node[1]) |
| return [c for n in node[1] for c in conds_of(n)] |
|
|
|
|
| def build_tree(rng: random.Random, pool: list, exc_pool: list, n: int = 3, allow_exc: bool = True): |
| specs = rng.sample(pool, n) |
| cs = [("c", Cond(sp, rng)) for sp in specs] |
| form = rng.choice(["and", "and", "or_in", "or_out"]) |
| if form == "and" or n < 3: |
| node = ("and", cs) |
| elif form == "or_in": |
| node = ("and", [cs[0], ("or", cs[1:])]) |
| else: |
| node = ("or", [("and", cs[:2]), cs[2]]) |
| if allow_exc and exc_pool and rng.random() < 0.4: |
| e = ("not", ("c", Cond(rng.choice(exc_pool), rng))) |
| node = ("and", [node, e]) if node[0] != "and" else ("and", node[1] + [e]) |
| return node |
|
|
|
|
| def render_tree(node): |
| """The tree as a phrase for a sentence; a nested or reads "either ... or ...".""" |
| if node[0] == "c": |
| return node[1].phrase |
| if node[0] == "or": |
| sep = ", or " if any(m[0] != "c" for m in node[1]) else " or " |
| return "either " + sep.join(render_tree(m) for m in node[1]) |
| parts = [render_tree(n) for n in node[1] if n[0] != "not"] |
| exc = [n[1][1].exc for n in node[1] if n[0] == "not"] |
| s = parts[0] if len(parts) == 1 else ", ".join(parts[:-1]) + " and " + parts[-1] |
| return s + (", unless the applicant " + " or ".join(exc) if exc else "") |
|
|
|
|
| def sample_facts(rng: random.Random, node, target: bool, tries: int = 300): |
| cs = conds_of(node) |
| for _ in range(tries): |
| p = rng.choice([0.3, 0.5, 0.7, 0.9]) |
| facts = {} |
| for c in cs: |
| if c.key in facts: |
| continue |
| facts[c.key] = c.sample(rng, rng.random() < (1 - p if c.exc else p)) |
| if ev3(node, facts) == target: |
| return facts |
| return None |
|
|
|
|
| def pivots(node, facts): |
| """Facts whose removal leaves the outcome undecided.""" |
| return [k for k in facts if ev3(node, {a: b for a, b in facts.items() if a != k}) is None] |
|
|
|
|
| |
| ADM_POOL = [ |
| dict(key="gpa", kind="ge", ts=[2.8, 3.0, 3.2, 3.4, 3.6], lo=2.0, hi=4.0, step=0.1, dec=1, phrase="has a GPA of at least {t}"), |
| dict(key="entrance_exam_score", kind="ge", ts=[60, 65, 70, 75, 80], lo=30, hi=100, phrase="scored at least {t} on the entrance exam"), |
| dict(key="recommendation_letters", kind="ge", ts=[2, 3, 4], lo=0, hi=6, phrase="has at least {t} recommendation letters"), |
| dict(key="years_of_work_experience", kind="ge", ts=[2, 3, 5, 8], lo=0, hi=20, phrase="has at least {t} years of work experience"), |
| dict(key="age", kind="le", ts=[28, 30, 35, 40], lo=17, hi=55, phrase="is at most {t} years old"), |
| dict(key="submitted_before_deadline", kind="bool", phrase="submitted the application before the deadline"), |
| dict(key="portfolio_included", kind="bool", phrase="included a portfolio"), |
| dict(key="application_fee_paid", kind="bool", phrase="paid the application fee"), |
| dict(key="highest_degree", kind="in", opts=["bachelor's degree", "master's degree", "doctorate"], |
| other=["high school diploma", "associate degree", "none"], phrase="holds a bachelor's degree or higher"), |
| ] |
| ADM_EXC = [ |
| dict(key="disciplinary_record", kind="bool", exc="has a disciplinary record"), |
| dict(key="plagiarism_flag", kind="bool", exc="has a plagiarism flag on file"), |
| dict(key="unpaid_tuition", kind="bool", exc="owes unpaid tuition from an earlier enrolment"), |
| ] |
| ADM_EXTRA = {"applicant": lambda r: r.choice(NAMES), "intended_program": lambda r: r.choice( |
| ["Chemistry", "Economics", "Computer Science", "History", "Nursing", "Design", "Physics"]), |
| "country": lambda r: r.choice(["Poland", "Brazil", "Japan", "Kenya", "Canada", "Germany", "India"])} |
| ADM_LEADS = ("Our admissions policy accepts an applicant who {r}. Should this applicant be admitted?", |
| "Policy: an applicant is admitted if the applicant {r}. Should this applicant be admitted?", |
| "The programme admits an applicant who {r}. Based on the record, should this applicant be admitted?") |
|
|
|
|
| def gen_admission(rng: random.Random, target: bool): |
| for _ in range(100): |
| node = build_tree(rng, ADM_POOL, ADM_EXC, n=rng.choice([2, 3, 3, 4])) |
| facts = sample_facts(rng, node, target) |
| if facts is None: |
| continue |
| text = rng.choice(ADM_LEADS).format(r=render_tree(node)) |
| state = {k: f(rng) for k, f in ADM_EXTRA.items()} |
| items = list(facts.items()) |
| rng.shuffle(items) |
| state.update(dict(items)) |
| return node, state, facts, text |
| raise RuntimeError("admission generator failed") |
|
|
|
|
| def admission(n: int, rng: random.Random) -> list: |
| out = [] |
| for i in range(n): |
| target = i % 2 == 0 |
| node, state, facts, text = gen_admission(rng, target) |
| assert ev3(node, facts) == target |
| out.append(_item(f"rules7-admission-{i:04d}", "admission", "rules7:admission", state, {"admit": noul(text)}, |
| {"admit": noul_target(target)})) |
| return out |
|
|
|
|
| |
| AGENT = { |
| "spend money": dict( |
| pool=[dict(key="amount_usd", kind="le", ts=[50, 100, 250, 500, 1000], lo=1, hi=3000, step=10, phrase="the amount is at most ${t}"), |
| dict(key="vendor_on_approved_list", kind="bool", phrase="the vendor is on the approved list"), |
| dict(key="manager_approved", kind="bool", phrase="a manager has approved it"), |
| dict(key="budget_remaining_usd", kind="ge", ts=[500, 1000, 2000], lo=0, hi=6000, step=50, phrase="the remaining budget is at least ${t}")], |
| exc=[dict(key="purchase_is_recurring", kind="bool", exc="is a recurring subscription")], |
| stem="Spending money", extra={"description": ["software licence", "conference ticket", "cloud credits", "office supplies"]}), |
| "send an email": dict( |
| pool=[dict(key="recipient_is_internal", kind="bool", phrase="the recipient is inside the company"), |
| dict(key="contains_customer_data", kind="notbool", phrase="the message contains no customer data"), |
| dict(key="manager_approved", kind="bool", phrase="a manager has approved it"), |
| dict(key="recipient_count", kind="le", ts=[1, 3, 5, 10], lo=1, hi=30, phrase="it goes to at most {t} recipients")], |
| exc=[dict(key="marketing_content", kind="bool", exc="is marketing content")], |
| stem="Sending an email", extra={"subject": ["Quarterly numbers", "Meeting notes", "Invoice question", "Launch update"]}), |
| "delete a file": dict( |
| pool=[dict(key="location", kind="in", opts=["sandbox"], other=["staging", "production", "shared drive"], phrase="the file is in the sandbox"), |
| dict(key="backup_exists", kind="bool", phrase="a backup exists"), |
| dict(key="file_age_days", kind="ge", ts=[30, 90, 180, 365], lo=0, hi=900, step=10, phrase="the file is at least {t} days old"), |
| dict(key="created_by_agent", kind="bool", phrase="the agent created the file")], |
| exc=[dict(key="under_legal_hold", kind="bool", exc="is under legal hold")], |
| stem="Deleting a file", extra={"file": ["report_q3.csv", "tmp_export.json", "notes.txt", "build.log"]}), |
| "deploy code": dict( |
| pool=[dict(key="tests_passed", kind="bool", phrase="all tests passed"), |
| dict(key="reviewer_approvals", kind="ge", ts=[1, 2, 3], lo=0, hi=5, phrase="at least {t} reviewers approved it"), |
| dict(key="lines_changed", kind="le", ts=[100, 300, 500, 1000], lo=1, hi=2500, step=20, phrase="the change touches at most {t} lines"), |
| dict(key="rollback_plan", kind="bool", phrase="a rollback plan is attached")], |
| exc=[dict(key="change_freeze", kind="bool", exc="is during a change freeze")], |
| stem="Deploying code", extra={"service": ["billing-api", "web-frontend", "search-index", "auth"]}), |
| "read data": dict( |
| pool=[dict(key="data_sensitivity_level", kind="le", ts=[1, 2, 3], lo=1, hi=5, phrase="the data sensitivity level is at most {t}"), |
| dict(key="purpose_logged", kind="bool", phrase="the purpose is logged"), |
| dict(key="user_consented", kind="bool", phrase="the user consented"), |
| dict(key="requester_in_team", kind="bool", phrase="the requester is in the owning team")], |
| exc=[dict(key="subject_is_minor", kind="bool", exc="involves a minor's data")], |
| stem="Reading data", extra={"dataset": ["orders", "support tickets", "telemetry", "payroll"]}), |
| } |
| AGENT_LEADS = ("Rules for the agent: ", "The agent works under these rules. ", "Agent policy: ") |
|
|
|
|
| def agent_rules(n: int, rng: random.Random, with_missing: bool = False) -> list: |
| out = [] |
| for i in range(n): |
| target = i % 2 == 0 |
| for _ in range(100): |
| kinds = rng.sample(list(AGENT), 3) |
| trees = {k: build_tree(rng, AGENT[k]["pool"], AGENT[k]["exc"], n=3) for k in kinds} |
| act = rng.choice(kinds) |
| facts = sample_facts(rng, trees[act], target) |
| if facts is not None: |
| break |
| rules = [] |
| for k in kinds: |
| nd = trees[k] |
| body = render_tree(nd).replace(", unless the applicant", ", unless the action") |
| rules.append(f"{AGENT[k]['stem']} is allowed only if {body}.") |
| state = {"requested action": act, **{kk: rng.choice(vv) for kk, vv in AGENT[act]["extra"].items()}, **facts} |
| text = rng.choice(AGENT_LEADS) + " ".join(f"({j + 1}) {r}" for j, r in enumerate(rules)) + \ |
| " May the agent take the requested action?" |
| out.append(_item(f"rules7-agent_rules-{i:04d}", "agent_rules", "rules7:agent_rules", state, |
| {"allowed": noul(text)}, {"allowed": noul_target(ev3(trees[act], facts))})) |
| assert ev3(trees[act], facts) == target |
| return out |
|
|
|
|
| |
| RENT_OPTS = {"decline": "the rental is refused", "approve": "the rental is approved at the standard terms", |
| "approve_with_surcharge": "approved with a young-driver surcharge", |
| "require_deposit": "approved but a security deposit is required", |
| "surcharge_and_deposit": "approved with both a surcharge and a deposit"} |
|
|
|
|
| def gen_rental(rng: random.Random, want: str): |
| for _ in range(500): |
| min_age = rng.choice([21, 23, 25]) |
| young = rng.choice([25, 27, 30]) |
| lic = rng.choice([1, 2, 3]) |
| dep_rule = rng.choice(["luxury", "debit", "either"]) |
| dui = rng.choice([3, 5]) |
| facts = {"renter_age": rng.randint(min_age - 3, 45), "licence_years": rng.randint(0, 8), |
| "vehicle_class": rng.choice(["economy", "compact", "suv", "luxury"]), |
| "payment_method": rng.choice(["credit card", "debit card"]), |
| "dui_conviction_years_ago": rng.choice([None, None, 1, 2, 4, 6, 10]), |
| "rental_days": rng.randint(1, 21)} |
| decline = facts["renter_age"] < min_age or facts["licence_years"] < lic or \ |
| (facts["dui_conviction_years_ago"] is not None and facts["dui_conviction_years_ago"] < dui) |
| sur = facts["renter_age"] < young |
| dep = {"luxury": facts["vehicle_class"] == "luxury", "debit": facts["payment_method"] == "debit card", |
| "either": facts["vehicle_class"] == "luxury" or facts["payment_method"] == "debit card"}[dep_rule] |
| gold = "decline" if decline else ("surcharge_and_deposit" if sur and dep else "approve_with_surcharge" if sur |
| else "require_deposit" if dep else "approve") |
| if gold != want: |
| continue |
| dep_txt = {"luxury": "the vehicle is in the luxury class", "debit": "the renter pays by debit card", |
| "either": "the vehicle is in the luxury class or the renter pays by debit card"}[dep_rule] |
| text = (f"Rental policy: refuse the rental if the renter is under {min_age}, has held a licence for less than " |
| f"{lic} year{'s' if lic > 1 else ''}, or has a DUI conviction within the last {dui} years. " |
| f"Otherwise approve it, adding a young-driver surcharge if the renter is under {young}, and requiring a " |
| f"security deposit if {dep_txt}. What should we do with this rental request?") |
| return facts, text, gold |
| raise RuntimeError("rental generator failed") |
|
|
|
|
| def rental(n: int, rng: random.Random) -> list: |
| order = list(RENT_OPTS) |
| out = [] |
| for i in range(n): |
| facts, text, gold = gen_rental(rng, order[i % len(order)]) |
| state = {"renter": rng.choice(NAMES), **{k: v for k, v in facts.items() if v is not None}} |
| if facts["dui_conviction_years_ago"] is None: |
| state["dui_conviction"] = "none on record" |
| opts = list(RENT_OPTS) |
| rng.shuffle(opts) |
| out.append(_item(f"rules7-rental-{i:04d}", "rental", "rules7:rental", state, |
| {"decision": choice(text, {o: RENT_OPTS[o] for o in opts})}, {"decision": onehot(opts, gold)})) |
| return out |
|
|
|
|
| |
| ROLES = {"team_lead": "a team lead", "department_head": "a department head", "cfo": "the CFO", |
| "general_counsel": "the general counsel", "hr_director": "the HR director"} |
|
|
|
|
| def gen_authority(rng: random.Random, want: str): |
| for _ in range(500): |
| t1 = rng.choice([200, 500, 1000, 2000]) |
| t2 = t1 * rng.choice([5, 10]) |
| rtype = rng.choice(["purchase", "purchase", "contract", "hire", "travel", "software licence"]) |
| amount = int(rng.choice([t1 * 0.3, t1 * 0.9, t1, t1 * 1.1, t2 * 0.5, t2, t2 * 1.2, t2 * 3])) |
| salary_cap = rng.choice([60000, 80000, 100000]) |
| salary = rng.choice([salary_cap - 10000, salary_cap, salary_cap + 5000, salary_cap + 30000]) |
| facts = {"request_type": rtype, "requested_by": rng.choice(NAMES)} |
| if rtype == "hire": |
| facts["annual_salary_usd"] = salary |
| gold = "department_head" if salary <= salary_cap else "hr_director" |
| else: |
| facts["amount_usd"] = amount |
| if rtype == "contract": |
| gold = "general_counsel" |
| elif rtype == "software licence": |
| gold = "department_head" if amount <= t2 else "cfo" |
| elif rtype == "travel": |
| gold = "team_lead" if amount <= t2 // 4 else "department_head" |
| else: |
| gold = "team_lead" if amount <= t1 else ("department_head" if amount <= t2 else "cfo") |
| if gold != want: |
| continue |
| text = (f"Approval rules: purchases up to ${t1} can be approved by a team lead, up to ${t2} by a department head, " |
| f"and anything above that by the CFO. Travel up to ${t2 // 4} can be approved by a team lead, above that " |
| f"by a department head. Software licences up to ${t2} go to a department head, above that to the CFO. " |
| f"Every contract, whatever its value, goes to the general counsel. A hire with an annual salary up to " |
| f"${salary_cap} is approved by a department head, a higher salary by the HR director. " |
| f"Who may approve this request?") |
| return facts, text, gold |
| raise RuntimeError("authority generator failed") |
|
|
|
|
| def authority(n: int, rng: random.Random) -> list: |
| order = list(ROLES) |
| out = [] |
| for i in range(n): |
| facts, text, gold = gen_authority(rng, order[i % len(order)]) |
| opts = list(ROLES) |
| rng.shuffle(opts) |
| out.append(_item(f"rules7-authority-{i:04d}", "authority", "rules7:authority", facts, |
| {"approver": choice(text, {o: ROLES[o] for o in opts})}, {"approver": onehot(opts, gold)})) |
| return out |
|
|
|
|
| |
| FRAUD_RULES = [ |
| dict(key="account_age_days", kind="lt", ts=[7, 14, 30], lo=0, hi=900, step=1, ph="the account is less than {t} days old"), |
| dict(key="billing_shipping_countries_differ", kind="bool", ph="the billing and shipping countries differ"), |
| dict(key="order_total_usd", kind="ge", ts=[300, 500, 1000, 2000], lo=10, hi=4000, step=25, ph="the order total is at least ${t}"), |
| dict(key="failed_payment_attempts", kind="ge", ts=[2, 3, 4], lo=0, hi=8, step=1, ph="there were at least {t} failed payment attempts"), |
| dict(key="new_device", kind="bool", ph="the order comes from a device not seen before"), |
| dict(key="vpn_or_proxy", kind="bool", ph="the connection uses a VPN or proxy"), |
| dict(key="local_hour", kind="in", opts=[1, 2, 3, 4], other=[8, 9, 10, 12, 14, 16, 19, 21], ph="the order was placed between 01:00 and 04:59 local time"), |
| dict(key="previous_chargebacks", kind="ge", ts=[1, 2], lo=0, hi=5, step=1, ph="the customer has at least {t} earlier chargebacks"), |
| dict(key="disposable_email", kind="bool", ph="the email address is from a disposable-email provider"), |
| dict(key="freight_forwarder_address", kind="bool", ph="the shipping address is a freight forwarder"), |
| ] |
| LEVELS = ["low", "medium", "high", "critical"] |
|
|
|
|
| def gen_fraud(rng: random.Random, want: int): |
| for _ in range(2000): |
| specs = rng.sample(FRAUD_RULES, 6) |
| rules = [] |
| for sp in specs: |
| c = Cond({**sp, "phrase": sp["ph"]}, rng) |
| rules.append((c, rng.choice([1, 2, 2, 3, 3, 4]))) |
| a = rng.choice([2, 3, 4]) |
| b = a + rng.choice([2, 3]) |
| d = b + rng.choice([2, 3]) |
| cut = (a, b, d) |
| p = rng.choice([0.2, 0.35, 0.5, 0.7]) |
| facts = {c.key: c.sample(rng, rng.random() < p) for c, _ in rules} |
| total = sum(pts for c, pts in rules if c.test(facts[c.key])) |
| lvl = sum(total >= x for x in cut) |
| if lvl != want: |
| continue |
| pts_txt = "; ".join(f"+{pts} if {c.phrase}" for c, pts in rules) |
| text = (f"Fraud score: add up the points: {pts_txt}. Risk level: below {cut[0]} points is low, {cut[0]} to " |
| f"{cut[1] - 1} is medium, {cut[1]} to {cut[2] - 1} is high, {cut[2]} or more is critical. " |
| f"What risk level does this order get?") |
| return rules, cut, facts, text, lvl |
| raise RuntimeError("fraud generator failed") |
|
|
|
|
| def fraud_level(rules, cut, facts): |
| total = sum(pts for c, pts in rules if c.key in facts and c.test(facts[c.key])) |
| return sum(total >= x for x in cut) |
|
|
|
|
| def fraud_pivots(rules, cut, facts): |
| """Facts whose removal leaves the level undecided (it differs with and without that rule's points).""" |
| out = [] |
| for c, pts in rules: |
| rest = sum(p for c2, p in rules if c2.key != c.key and c2.test(facts[c2.key])) |
| if sum(rest >= x for x in cut) != sum(rest + pts >= x for x in cut): |
| out.append(c.key) |
| return out |
|
|
|
|
| def fraud_state(rng, facts): |
| items = list(facts.items()) |
| rng.shuffle(items) |
| return {"order_id": f"ORD-{rng.randint(10000, 99999)}", "customer": rng.choice(NAMES), **dict(items)} |
|
|
|
|
| def fraud_points(n: int, rng: random.Random) -> list: |
| out = [] |
| for i in range(n): |
| rules, cut, facts, text, lvl = gen_fraud(rng, i % 4) |
| out.append(_item(f"rules7-fraud_points-{i:04d}", "fraud_points", "rules7:fraud_points", fraud_state(rng, facts), |
| {"risk": score_q(text, LEVELS)}, {"risk": {str(j): float(j == lvl) for j in range(4)}})) |
| return out |
|
|
|
|
| |
| def missing_facts(pairs: int, rng: random.Random) -> list: |
| out = [] |
| i = 0 |
| while i < pairs: |
| node, state, facts, text = gen_admission(rng, i % 2 == 0) |
| pv = pivots(node, facts) |
| if not pv: |
| continue |
| gone = rng.choice(pv) |
| gold = ev3(node, facts) |
| full = _item(f"rules7-missing_facts-admission-{i:04d}-complete", "missing_facts", "missing:admission:complete", |
| state, {"admit": noul(text)}, {"admit": noul_target(gold)}, variant="complete", pair=i, task="admission") |
| miss = {k: v for k, v in state.items() if k != gone} |
| part = _item(f"rules7-missing_facts-admission-{i:04d}-missing", "missing_facts", "missing:admission:missing", miss, |
| {"admit": noul(text)}, {}, variant="missing", pair=i, task="admission", removed=gone) |
| out += [full, part] |
| i += 1 |
| i = 0 |
| while i < pairs: |
| rules, cut, facts, text, lvl = gen_fraud(rng, i % 4) |
| pv = fraud_pivots(rules, cut, facts) |
| if not pv: |
| continue |
| gone = rng.choice(pv) |
| state = fraud_state(rng, facts) |
| full = _item(f"rules7-missing_facts-fraud_points-{i:04d}-complete", "missing_facts", "missing:fraud_points:complete", |
| state, {"risk": score_q(text, LEVELS)}, {"risk": {str(j): float(j == lvl) for j in range(4)}}, |
| variant="complete", pair=i, task="fraud_points") |
| part = _item(f"rules7-missing_facts-fraud_points-{i:04d}-missing", "missing_facts", "missing:fraud_points:missing", |
| {k: v for k, v in state.items() if k != gone}, {"risk": score_q(text, LEVELS)}, {}, |
| variant="missing", pair=i, task="fraud_points", removed=gone) |
| out += [full, part] |
| i += 1 |
| return out |
|
|
|
|
| |
| def _clean(t) -> str: |
| return " ".join(str(t).split()) if t is not None else "" |
|
|
|
|
| def _norm(t) -> str: |
| import re |
|
|
| return re.sub(r"\W+", " ", str(t).lower()).strip() |
|
|
|
|
| def load_exclusions() -> dict: |
| """Rule texts excluded from the ShARC selection (duplicated rule texts; normalised, first 200 chars): drop_keys.json, |
| 2 rule texts, 36 dev rows. Nothing is excluded from the patent phrases.""" |
| import os |
|
|
| p = os.path.join(os.path.dirname(os.path.abspath(__file__)), "drop_keys.json") |
| return {"sharc_drop": set(json.load(open(p))), "pairs": set(), "anchors": set()} |
|
|
|
|
| def sharc(n: int, rng: random.Random, pools: dict | None = None) -> tuple[list, dict]: |
| """ShARC dev (CC BY-SA 3.0), the rows whose answer is yes or no (no follow-up question needed), balanced; at most |
| eight utterances per rule text (the dev split has only 56 rule texts with yes / no answers).""" |
| import pandas as pd |
| from huggingface_hub import hf_hub_download |
|
|
| repo, rev, f = SHARC |
| df = pd.read_parquet(hf_hub_download(repo, f, repo_type="dataset", revision=rev)) |
| df = df[df.label.isin([0, 1])] |
| rows = df.to_dict("records") |
| dropped = 0 |
| if pools: |
| bad = {} |
| keep = [] |
| for r in rows: |
| k = _norm(r["snippet"])[:200] |
| if k not in bad: |
| bad[k] = k in pools["sharc_drop"] |
| if bad[k]: |
| dropped += 1 |
| else: |
| keep.append(r) |
| rows = keep |
| rng.shuffle(rows) |
| per_tree, picked = {}, {True: [], False: []} |
| for r in rows: |
| yes = int(r["label"]) == 0 |
| if per_tree.get(r["tree_id"], 0) >= 8 or len(picked[yes]) >= n // 2: |
| continue |
| per_tree[r["tree_id"]] = per_tree.get(r["tree_id"], 0) + 1 |
| picked[yes].append(r) |
| out = [] |
| for j, r in enumerate(sorted(picked[True] + picked[False], key=lambda r: r["utterance_id"])): |
| state = {"rule text": _clean(r["snippet"]), "scenario": _clean(r["scenario"]) or "(none given)", |
| "conversation so far": _clean(r["history"]).replace(" Q:", "\nQ:").replace(" A:", "\nA:") or "(none)", |
| "user question": _clean(r["question"])} |
| q = noul("Using only the rule text, the scenario and the conversation so far, do the rules say that the answer to " |
| "the user's question is yes?") |
| out.append(_item(f"rules7-sharc-{r['utterance_id'][:12]}", "sharc", "sharc:dev", state, {"answer": q}, |
| {"answer": noul_target(int(r["label"]) == 0)}, license="CC-BY-SA-3.0", split="public")) |
| info = {"dataset": f"{SHARC[0]}@{SHARC[1]}", "file": SHARC[2], "dev_rows": int(len(pd.read_parquet(hf_hub_download( |
| repo, f, repo_type="dataset", revision=rev)))), "yes_no_rows": int(len(df)), |
| "excluded_rule_texts": dropped} |
| return out, info |
|
|
|
|
| PATENT_LEVELS = ["not related (0)", "somewhat related (0.25)", "synonym with a different breadth, e.g. hypernym or " |
| "hyponym (0.5)", "close synonym (0.75)", "very close match (1.0)"] |
|
|
|
|
| def patent_phrases(n: int, rng: random.Random, pools: dict | None = None) -> tuple[list, dict]: |
| """US Patent Phrase-to-Phrase Matching, the held-out (test) split of tasksource/patent-phrase-similarity with the |
| expert scores 0 / 0.25 / 0.5 / 0.75 / 1; balanced over the five levels.""" |
| import pandas as pd |
| from huggingface_hub import hf_hub_download |
|
|
| repo, rev, f = PATENT |
| df = pd.read_parquet(hf_hub_download(repo, f, repo_type="dataset", revision=rev)) |
| df = df.drop_duplicates(["anchor", "target", "context"]) |
| dropped = 0 |
| if pools: |
| mask = [(_norm(a), _norm(t)) in pools["pairs"] or _norm(a) in pools["anchors"] |
| for a, t in zip(df.anchor, df.target, strict=True)] |
| dropped = int(sum(mask)) |
| df = df[[not m for m in mask]] |
| by = {j: [r for r in df.to_dict("records") if abs(float(r["score"]) - j / 4) < 1e-6] for j in range(5)} |
| out = [] |
| for j in range(5): |
| rng.shuffle(by[j]) |
| for r in by[j][:n // 5]: |
| state = {"phrase A": r["anchor"], "phrase B": r["target"], "technical field (CPC class)": r["context"]} |
| q = score_q("In patent language, how similar in meaning is phrase B to phrase A, in the given technical " |
| "field?", PATENT_LEVELS) |
| out.append(_item(f"rules7-patent-{hashlib.sha1((r['anchor'] + '|' + r['target'] + '|' + r['context']).encode()).hexdigest()[:12]}", |
| "patent_phrases", "patent_phrases:test", state, {"similarity": q}, |
| {"similarity": {str(k): float(k == j) for k in range(5)}}, license="CC-BY-4.0", |
| split="public")) |
| rng.shuffle(out) |
| return out, {"dataset": f"{PATENT[0]}@{PATENT[1]}", "file": PATENT[2], "rows": int(len(df)), |
| "excluded_pairs": dropped} |
|
|
|
|
| |
| def build(seed: int = 0, sizes: dict | None = None, public: bool = True, screen: bool = True) -> tuple[list, dict]: |
| sz = {**SIZES, **(sizes or {})} |
| items, info = [], {"version": VERSION, "seed": seed} |
| items += admission(sz["admission"], random.Random(f"{seed}:admission")) |
| items += rental(sz["rental"], random.Random(f"{seed}:rental")) |
| items += agent_rules(sz["agent_rules"], random.Random(f"{seed}:agent")) |
| items += authority(sz["authority"], random.Random(f"{seed}:authority")) |
| items += fraud_points(sz["fraud_points"], random.Random(f"{seed}:fraud")) |
| if public: |
| pools = load_exclusions() if screen else None |
| its, info["sharc"] = sharc(sz["sharc"], random.Random(f"{seed}:sharc"), pools) |
| items += its |
| its, info["patent"] = patent_phrases(sz["patent_phrases"], random.Random(f"{seed}:patent"), pools) |
| items += its |
| items += missing_facts(sz["missing_facts"], random.Random(f"{seed}:missing")) |
| ids = set() |
| for x in items: |
| assert x["id"] not in ids, x["id"] |
| ids.add(x["id"]) |
| info["counts"] = {s: sum(x["skill"] == s for x in items) for s in SKILLS} |
| info["gold"] = {} |
| for s in SKILLS: |
| c = {} |
| for x in items: |
| if x["skill"] == s: |
| for k, t in x["targets"].items(): |
| g = max(t, key=t.get) |
| c[g] = c.get(g, 0) + 1 |
| info["gold"][s] = dict(sorted(c.items())) |
| return items, info |
|
|
|
|
| def state_hashes(items: list) -> list: |
| return sorted({hashlib.sha1(x["state"].encode()).hexdigest() for x in items}) |
|
|
|
|
| def write(items: list, info: dict, outdir: str = ".") -> list: |
| import os |
|
|
| p = os.path.join(outdir, "rules7_v1_items.json.gz") |
| with gzip.open(p, "wt") as fh: |
| json.dump(items, fh, ensure_ascii=False) |
| return [p] |
|
|
|
|
| if __name__ == "__main__": |
| import argparse |
|
|
| ap = argparse.ArgumentParser(description="build Rules7 v1 items") |
| ap.add_argument("--seed", type=int, default=0) |
| ap.add_argument("--out", default=".") |
| a = ap.parse_args() |
| its, inf = build(a.seed) |
| print(json.dumps(inf, indent=1)) |
| print(write(its, inf, a.out)) |
|
|
