| import json |
| import math |
| import os |
| import random |
| from typing import Dict, List |
|
|
| ACTION_CATALOG = { |
| "mask_direct_id": {"base_cost": 0.05, "modalities": ["text", "image"], "reduces": 0.35}, |
| "generalize_dob": {"base_cost": 0.03, "modalities": ["text", "ehr"], "reduces": 0.12}, |
| "suppress_geo": {"base_cost": 0.04, "modalities": ["text", "ehr"], "reduces": 0.10}, |
| "redact_image_face": {"base_cost": 0.12, "modalities": ["image"], "reduces": 0.20}, |
| "redact_image_tag": {"base_cost": 0.08, "modalities": ["image"], "reduces": 0.14}, |
| "strip_audio_voice": {"base_cost": 0.15, "modalities": ["audio"], "reduces": 0.18}, |
| "anon_audio_content": {"base_cost": 0.10, "modalities": ["audio"], "reduces": 0.12}, |
| "drop_rare_code": {"base_cost": 0.06, "modalities": ["ehr"], "reduces": 0.09}, |
| "k_anon_table": {"base_cost": 0.20, "modalities": ["ehr", "text"], "reduces": 0.22}, |
| "perturb_numerics": {"base_cost": 0.07, "modalities": ["ehr"], "reduces": 0.07}, |
| "retokenize_text": {"base_cost": 0.09, "modalities": ["text"], "reduces": 0.11}, |
| "cross_modal_unlink": {"base_cost": 0.18, "modalities": ["text", "image", "audio", "ehr"], "reduces": 0.28}, |
| "federated_noise": {"base_cost": 0.25, "modalities": ["text", "image", "audio", "ehr"], "reduces": 0.15}, |
| "audit_log_purge": {"base_cost": 0.02, "modalities": ["text", "image", "audio", "ehr"], "reduces": 0.03}, |
| } |
|
|
| PRECEDE = { |
| "retokenize_text": ["mask_direct_id"], |
| "k_anon_table": ["generalize_dob", "suppress_geo", "drop_rare_code"], |
| "cross_modal_unlink": ["redact_image_face", "strip_audio_voice", "mask_direct_id"], |
| "federated_noise": ["k_anon_table", "cross_modal_unlink"], |
| "audit_log_purge": ["federated_noise"], |
| "redact_image_tag": ["redact_image_face"], |
| "anon_audio_content": ["strip_audio_voice"], |
| } |
|
|
| RISK_THRESHOLD = 0.20 |
| ALL_MODALITIES = ["text", "image", "audio", "ehr"] |
|
|
|
|
| def _score(action: str, meta: Dict, risk: float, retok: float, active: List[str], mw: Dict) -> float: |
| overlap = [m for m in meta["modalities"] if m in active] |
| if not overlap: |
| return 0.0 |
| w = max(mw.get(m, 1.0) for m in overlap) |
| rb = 0.15 if action == "retokenize_text" and retok > 0.55 else 0.0 |
| roi = (meta["reduces"] * w + rb) / (meta["base_cost"] + 1e-9) |
| return roi * math.log1p(risk * 5.0) |
|
|
|
|
| def _select(risk: float, retok: float, active: List[str], budget: float, mw: Dict) -> Dict: |
| scored = sorted( |
| [(a, m, _score(a, m, risk, retok, active, mw)) for a, m in ACTION_CATALOG.items() if _score(a, m, risk, retok, active, mw) > 0], |
| key=lambda x: -x[2], |
| ) |
| selected = {} |
| cumcost = cumred = 0.0 |
| target = max(0.0, risk - RISK_THRESHOLD) |
| for action, meta, s in scored: |
| if cumcost + meta["base_cost"] > budget: |
| continue |
| selected[action] = (s, meta) |
| cumcost += meta["base_cost"] |
| cumred += meta["reduces"] |
| if cumred >= target and cumcost >= 0.1: |
| break |
| return selected |
|
|
|
|
| def _build_nodes(selected: Dict) -> Dict: |
| nodes = {a: {"score": s, "meta": m, "deps": []} for a, (s, m) in selected.items()} |
| injected = [] |
| for action in list(nodes.keys()): |
| for dep in PRECEDE.get(action, []): |
| if dep in nodes: |
| nodes[action]["deps"].append(dep) |
| elif dep in ACTION_CATALOG: |
| nodes[dep] = {"score": 0.01, "meta": ACTION_CATALOG[dep], "deps": [], "injected": True} |
| nodes[action]["deps"].append(dep) |
| injected.append(dep) |
| return nodes, injected |
|
|
|
|
| def _topo(nodes: Dict) -> List[str]: |
| visited, order = set(), [] |
| def visit(n): |
| if n in visited: |
| return |
| visited.add(n) |
| for dep in nodes[n]["deps"]: |
| if dep in nodes: |
| visit(dep) |
| order.append(n) |
| for n in sorted(nodes.keys(), key=lambda x: -nodes[x]["score"]): |
| visit(n) |
| return order |
|
|
|
|
| def plan(risk: float, retok: float, active: List[str], budget: float, mw: Dict, patient_id: str) -> Dict: |
| if risk <= RISK_THRESHOLD: |
| return { |
| "patient_id": patient_id, |
| "input": {"risk_score": risk, "retok_prob": retok, "active_modalities": active, "budget": budget}, |
| "plan": [], |
| "trace": {"selected_actions": [], "injected_deps": [], "topo_order": []}, |
| "estimated_residual_risk": risk, |
| "total_cost": 0.0, |
| "status": "below_threshold", |
| } |
|
|
| selected = _select(risk, retok, active, budget, mw) |
| nodes, injected = _build_nodes(selected) |
| order = _topo(nodes) |
|
|
| plan_out = [ |
| { |
| "action": a, |
| "priority": round(nodes[a]["score"], 4), |
| "cost": nodes[a]["meta"]["base_cost"], |
| "risk_delta": nodes[a]["meta"]["reduces"], |
| "deps": nodes[a]["deps"], |
| } |
| for a in order |
| ] |
| total_red = sum(nodes[a]["meta"]["reduces"] for a in nodes) |
| total_cost = sum(nodes[a]["meta"]["base_cost"] for a in nodes) |
| residual = round(max(0.0, risk - total_red), 4) |
|
|
| return { |
| "patient_id": patient_id, |
| "input": {"risk_score": round(risk, 4), "retok_prob": round(retok, 4), |
| "active_modalities": active, "budget": budget}, |
| "plan": plan_out, |
| "trace": { |
| "selected_actions": list(selected.keys()), |
| "injected_deps": injected, |
| "topo_order": order, |
| "score_breakdown": {a: round(nodes[a]["score"], 4) for a in order}, |
| }, |
| "estimated_residual_risk": residual, |
| "total_cost": round(total_cost, 4), |
| "status": "plan_ready" if residual <= RISK_THRESHOLD else "partial_plan", |
| } |
|
|
|
|
| def generate_record(idx: int, rng: random.Random) -> Dict: |
| risk = round(rng.uniform(0.05, 0.99), 4) |
| retok = round(rng.uniform(0.0, 1.0), 4) |
| n_mod = rng.randint(1, 4) |
| active = rng.sample(ALL_MODALITIES, n_mod) |
| budget = round(rng.uniform(0.4, 1.5), 2) |
| mw = {m: round(rng.uniform(0.8, 1.5), 2) for m in active if rng.random() < 0.4} |
| pid = "P-%06d" % idx |
| return plan(risk, retok, active, budget, mw, pid) |
|
|
|
|
| def main(): |
| os.makedirs("data", exist_ok=True) |
| rng = random.Random(7) |
|
|
| train = [generate_record(i, rng) for i in range(6000)] |
| test = [generate_record(i, rng) for i in range(6000, 7500)] |
|
|
| with open("data/train.jsonl", "w") as f: |
| for r in train: |
| f.write(json.dumps(r) + "\n") |
|
|
| with open("data/test.jsonl", "w") as f: |
| for r in test: |
| f.write(json.dumps(r) + "\n") |
|
|
| hard = [] |
| rng_hard = random.Random(42) |
| idx = 0 |
| while len(hard) < 1000: |
| risk = round(rng_hard.uniform(0.75, 0.99), 4) |
| retok = round(rng_hard.uniform(0.0, 1.0), 4) |
| n_mod = rng_hard.randint(1, 4) |
| active = rng_hard.sample(ALL_MODALITIES, n_mod) |
| budget = round(rng_hard.uniform(0.3, 0.6), 2) |
| mw = {m: round(rng_hard.uniform(0.8, 1.5), 2) for m in active if rng_hard.random() < 0.4} |
| pid = "P-H%05d" % idx |
| hard.append(plan(risk, retok, active, budget, mw, pid)) |
| idx += 1 |
|
|
| with open("data/hard.jsonl", "w") as f: |
| for r in hard: |
| f.write(json.dumps(r) + "\n") |
|
|
| train_statuses = {} |
| for r in train: |
| s = r["status"] |
| train_statuses[s] = train_statuses.get(s, 0) + 1 |
|
|
| hard_statuses = {} |
| for r in hard: |
| s = r["status"] |
| hard_statuses[s] = hard_statuses.get(s, 0) + 1 |
|
|
| train_planned = [r for r in train if r["status"] == "plan_ready"] |
| hard_planned = [r for r in hard if r["status"] == "plan_ready"] |
|
|
| avg_actions_all_train = sum(len(r["plan"]) for r in train) / len(train) |
| avg_residual_all_train = sum(r["estimated_residual_risk"] for r in train) / len(train) |
| avg_actions_pln_train = sum(len(r["plan"]) for r in train_planned) / len(train_planned) |
| avg_residual_pln_train = sum(r["estimated_residual_risk"] for r in train_planned) / len(train_planned) |
|
|
| avg_actions_all_hard = sum(len(r["plan"]) for r in hard) / len(hard) |
| avg_residual_all_hard = sum(r["estimated_residual_risk"] for r in hard) / len(hard) |
| avg_actions_pln_hard = sum(len(r["plan"]) for r in hard_planned) / len(hard_planned) |
| avg_residual_pln_hard = sum(r["estimated_residual_risk"] for r in hard_planned) / len(hard_planned) |
|
|
| print("train: %d test: %d hard: %d" % (len(train), len(test), len(hard))) |
| print("train status dist:", train_statuses) |
| print("hard status dist:", hard_statuses) |
| print() |
| print("train avg actions -- all: %.2f planned only: %.2f" % (avg_actions_all_train, avg_actions_pln_train)) |
| print("train avg residual -- all: %.4f planned only: %.4f" % (avg_residual_all_train, avg_residual_pln_train)) |
| print("hard avg actions -- all: %.2f planned only: %.2f" % (avg_actions_all_hard, avg_actions_pln_hard)) |
| print("hard avg residual -- all: %.4f planned only: %.4f" % (avg_residual_all_hard, avg_residual_pln_hard)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
