Upload 3 files

config_dag.json

@@ -0,0 +1,42 @@
+{
+  "model_type": "dagplanner",
+  "architecture": "rule_dag",
+  "action_catalog_size": 14,
+  "modalities": [
+    "text",
+    "image",
+    "audio",
+    "ehr"
+  ],
+  "planner": {
+    "default_risk_threshold": 0.2,
+    "default_budget": 1.0,
+    "scoring": "roi_urgency",
+    "roi_formula": "(reduces * modality_weight + retok_boost) / base_cost * log1p(risk * 5)",
+    "dag_constraints": "topological_sort with PRECEDE rules"
+  },
+  "inputs": {
+    "risk_score": "float [0,1] from FedCRDT-Distill or DCPG Encoder",
+    "retok_prob": "float [0,1] retokenization probability from FedCRDT-Distill",
+    "active_modalities": "list of str",
+    "patient_id": "str, optional"
+  },
+  "outputs": {
+    "plan": "list of action dicts in execution order",
+    "estimated_residual_risk": "float",
+    "total_cost": "float, total cost including injected dependency actions",
+    "status": "below_threshold | plan_ready | partial_plan | no_actions_applicable",
+    "selected_cost": "float, cost of directly selected actions within budget",
+    "plan_item_injected": "bool, true if action was injected to satisfy a dependency"
+  },
+  "upstream_models": [
+    "vkatg/exposureguard-fedcrdt-distill",
+    "vkatg/exposureguard-dcpg-encoder"
+  ],
+  "datasets": [
+    "vkatg/dag-remediation-traces",
+    "vkatg/multimodal-phi-masking-benchmark"
+  ],
+  "dependencies": [],
+  "framework": "pure_python"
+}

dagplanner.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import math
+import json
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+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"],
+}
+
+
+class ExposureGuardDAGPlanner:
+
+    def __init__(
+        self,
+        risk_threshold: float = 0.20,
+        budget: float = 1.0,
+        modality_weights: Optional[Dict[str, float]] = None,
+    ):
+        self.risk_threshold = risk_threshold
+        self.budget = budget
+        self.mw = modality_weights or {}
+
+    def _score(self, action: str, meta: Dict, risk: float, retok: float, active: List[str]) -> float:
+        overlap = [m for m in meta["modalities"] if m in active]
+        if not overlap:
+            return 0.0
+        w  = max(self.mw.get(m, 1.0) for m in overlap)
+        rb = 0.15 if action == "retokenize_text" and retok > 0.55 else 0.0
+        return ((meta["reduces"] * w + rb) / (meta["base_cost"] + 1e-9)) * math.log1p(risk * 5.0)
+
+    def _select(self, risk: float, retok: float, active: List[str]) -> Dict:
+        scored = sorted(
+            [(a, m, self._score(a, m, risk, retok, active)) for a, m in ACTION_CATALOG.items()],
+            key=lambda x: -x[2],
+        )
+        selected = {}
+        cumcost = cumred = 0.0
+        target = max(0.0, risk - self.risk_threshold)
+        for action, meta, s in scored:
+            if s <= 0 or cumcost + meta["base_cost"] > self.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(self, selected: Dict) -> Dict:
+        nodes = {a: {"score": s, "meta": m, "deps": []} for a, (s, m) in selected.items()}
+        for action in list(nodes.keys()):
+            for dep in PRECEDE.get(action, []):
+                if dep not in nodes and dep in ACTION_CATALOG:
+                    nodes[dep] = {"score": 0.01, "meta": ACTION_CATALOG[dep], "deps": []}
+                if dep in nodes:
+                    nodes[action]["deps"].append(dep)
+        return nodes
+
+    def _topo(self, 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(
+        self,
+        risk_score: float,
+        retok_prob: float = 0.0,
+        active_modalities: Optional[List[str]] = None,
+        patient_id: Optional[str] = None,
+    ) -> Dict:
+        if active_modalities is None:
+            active_modalities = ["text", "image", "audio", "ehr"]
+
+        if risk_score <= self.risk_threshold:
+            return {
+                "patient_id": patient_id,
+                "risk_score": risk_score,
+                "retok_prob": retok_prob,
+                "plan": [],
+                "estimated_residual_risk": risk_score,
+                "total_cost": 0.0,
+                "status": "below_threshold",
+            }
+
+        selected = self._select(risk_score, retok_prob, active_modalities)
+        if not selected:
+            return {
+                "patient_id": patient_id,
+                "risk_score": round(risk_score, 4),
+                "retok_prob": round(retok_prob, 4),
+                "plan": [],
+                "estimated_residual_risk": round(risk_score, 4),
+                "total_cost": 0.0,
+                "status": "no_actions_applicable",
+            }
+
+        nodes   = self._build_nodes(selected)
+        order   = self._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"],
+                "injected":  nodes[a]["score"] == 0.01,
+            }
+            for a in order
+        ]
+        total_red       = sum(nodes[a]["meta"]["reduces"] for a in nodes)
+        selected_cost   = sum(nodes[a]["meta"]["base_cost"] for a in nodes if nodes[a]["score"] != 0.01)
+        total_cost      = sum(nodes[a]["meta"]["base_cost"] for a in nodes)
+        residual        = round(max(0.0, risk_score - total_red), 4)
+
+        return {
+            "patient_id":             patient_id,
+            "risk_score":             round(risk_score, 4),
+            "retok_prob":             round(retok_prob, 4),
+            "plan":                   plan_out,
+            "estimated_residual_risk":residual,
+            "selected_cost":          round(selected_cost, 4),
+            "total_cost":             round(total_cost, 4),
+            "status":                 "plan_ready" if residual <= self.risk_threshold else "partial_plan",
+        }
+
+    def batch_plan(self, records: List[Dict]) -> List[Dict]:
+        results = [
+            self.plan(
+                risk_score=r["risk_score"],
+                retok_prob=r.get("retok_prob", 0.0),
+                active_modalities=r.get("active_modalities"),
+                patient_id=r.get("patient_id"),
+            )
+            for r in records
+        ]
+        results.sort(key=lambda x: -x["risk_score"])
+        return results
+
+    def summary(self, result: Dict) -> str:
+        return "patient=%s risk=%.3f->%.3f actions=%d cost=%.3f status=%s" % (
+            result["patient_id"] or "?",
+            result["risk_score"],
+            result["estimated_residual_risk"],
+            len(result["plan"]),
+            result["total_cost"],
+            result["status"],
+        )

inference_dag.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import json
+import sys
+
+from dagplanner import ExposureGuardDAGPlanner
+
+
+def demo_single():
+    planner = ExposureGuardDAGPlanner(risk_threshold=0.20, budget=1.0)
+    result = planner.plan(
+        risk_score=0.74,
+        retok_prob=0.68,
+        active_modalities=["text", "image", "ehr"],
+        patient_id="P-0042",
+    )
+    print(planner.summary(result))
+    print(json.dumps(result, indent=2))
+    return result
+
+
+def demo_batch():
+    planner = ExposureGuardDAGPlanner(
+        risk_threshold=0.20,
+        budget=1.2,
+        modality_weights={"image": 1.4, "audio": 1.2},
+    )
+    records = [
+        {"patient_id": "P-001", "risk_score": 0.82, "retok_prob": 0.71,
+         "active_modalities": ["text", "image", "audio", "ehr"]},
+        {"patient_id": "P-002", "risk_score": 0.45, "retok_prob": 0.30,
+         "active_modalities": ["text", "ehr"]},
+        {"patient_id": "P-003", "risk_score": 0.15, "retok_prob": 0.10,
+         "active_modalities": ["ehr"]},
+        {"patient_id": "P-004", "risk_score": 0.61, "retok_prob": 0.58,
+         "active_modalities": ["text", "audio"]},
+    ]
+    results = planner.batch_plan(records)
+    for r in results:
+        print(planner.summary(r))
+    return results
+
+
+def demo_pipeline():
+    fedcrdt_out = {"patient_id": "P-0099", "risk_score": 0.67, "retok_prob": 0.61}
+    encoder_out = {"risk_score": 0.70}
+    merged_risk = 0.5 * fedcrdt_out["risk_score"] + 0.5 * encoder_out["risk_score"]
+
+    planner = ExposureGuardDAGPlanner(risk_threshold=0.20, budget=1.0)
+    result = planner.plan(
+        risk_score=merged_risk,
+        retok_prob=fedcrdt_out["retok_prob"],
+        active_modalities=["text", "image", "ehr"],
+        patient_id=fedcrdt_out["patient_id"],
+    )
+    print("\n--- Pipeline demo ---")
+    print(planner.summary(result))
+    return result
+
+
+if __name__ == "__main__":
+    print("=== Single ===")
+    demo_single()
+    print("\n=== Batch ===")
+    demo_batch()
+    demo_pipeline()