Upload convert_openjev.py with huggingface_hub

convert_openjev.py

@@ -0,0 +1,145 @@
+import hashlib
+import json
+from collections import Counter, defaultdict
+from datasets import load_dataset
+from alea.genbase import emit, q_choice, q_noul, q_score, validate_row, write_jsonl
+
+CONFIGS = {
+    "amount-extraction-control-v1": 10000,
+    "citation-control-v1": 10000,
+    "entity-alignment-control-v1": 10000,
+    "email-selection-control-v1": 10000,
+    "phone-extraction-control-v1": 10000,
+    "context-retention-control-v1": 10000,
+    "silent-failure-control-v1": 10000,
+    "ir-control-v1": 10000,
+    "mailroom-control-v1": 12000,
+    "sponsor-segment-control-v1": 8000,
+}
+MAX_OPTIONS = 16
+
+
+def parse_json_field(value):
+    if not isinstance(value, str):
+        return value
+    try:
+        return json.loads(value)
+    except Exception:
+        return value
+
+
+def fingerprint(row):
+    raw = json.dumps(row["state"], sort_keys=True, ensure_ascii=False) + json.dumps(row["questions"], sort_keys=True, ensure_ascii=False)
+    return hashlib.sha256(raw.encode()).hexdigest()
+
+
+def convert(ex, config, idx, split):
+    state = parse_json_field(ex["state_json"])
+    if isinstance(state, str):
+        state = state.strip()
+    question = ex["question"]
+    options = ex["options"]
+    target = ex["target"]
+    kind = str(ex["kind"]).lower()
+    if not isinstance(options, list) or not isinstance(target, list):
+        return None
+    if len(options) < 2 or len(options) > MAX_OPTIONS or len(options) != len(target):
+        return None
+    if any(not isinstance(o, (str, dict, list)) for o in options):
+        return None
+    if kind == "choice":
+        q = q_choice("answer", question, options, [float(x) for x in target])
+    elif kind == "score":
+        q = q_score("score", question, options, [float(x) for x in target])
+    elif kind == "noul":
+        if len(target) != 2:
+            return None
+        q = q_noul("answer", question, float(target[1]))
+    elif kind in ("multilabel", "multi_label"):
+        qs = [q_noul(f"label_{i}",
+                     f"Based on the state, {question} Is this criterion true: {opt}?",
+                     float(target[i])) for i, opt in enumerate(options)]
+        row = emit(f"openjev_{config}", idx, state, qs)
+        row["id"] = str(ex.get("id", row["id"]))
+        row["provenance"] = {"dataset": "ZefanCai/Open-Jev", "config": config,
+                             "group_id": ex.get("group_id"), "split": split,
+                             "source": ex.get("source")}
+        validate_row(row)
+        return row
+    else:
+        return None
+    row = emit(f"openjev_{config}", idx, state, [q])
+    row["id"] = str(ex.get("id", row["id"]))
+    row["provenance"] = {"dataset": "ZefanCai/Open-Jev", "config": config,
+                         "group_id": ex.get("group_id"), "split": split,
+                         "source": ex.get("source")}
+    validate_row(row)
+    return row
+
+
+def load_split(split):
+    rows, seen, groups = [], set(), defaultdict(set)
+    stats = Counter()
+    next_idx = 0
+    for config, limit in CONFIGS.items():
+        ds = load_dataset("ZefanCai/Open-Jev", config, split=split, streaming=True)
+        cfg_rows = 0
+        for ex in ds:
+            stats["raw"] += 1
+            kind = str(ex.get("kind", "")).lower()
+            stats[f"kind:{kind}"] += 1
+            row = convert(ex, config, next_idx, split)
+            next_idx += 1
+            if row is None:
+                stats["unsupported_or_invalid"] += 1
+                continue
+            group = row["provenance"].get("group_id")
+            if group is not None:
+                groups[config].add(str(group))
+            key = fingerprint(row)
+            if key in seen:
+                stats["duplicate_input"] += 1
+                continue
+            seen.add(key)
+            rows.append(row)
+            cfg_rows += 1
+            if cfg_rows >= limit:
+                break
+        stats[f"kept:{config}"] = cfg_rows
+    return rows, groups, stats
+
+
+def main():
+    train, train_groups, train_stats = load_split("train")
+    validation, val_groups, val_stats = load_split("validation")
+    overlap = {c: len(train_groups[c] & val_groups[c]) for c in CONFIGS}
+    if any(overlap.values()):
+        raise RuntimeError(f"group leakage across train/validation: {overlap}")
+    train_keys = {fingerprint(r) for r in train}
+    before = len(validation)
+    validation = [r for r in validation if fingerprint(r) not in train_keys]
+    write_jsonl(train, "data/openjev_train.jsonl")
+    write_jsonl(validation, "data/openjev_validation.jsonl")
+    report = {
+        "dataset": "ZefanCai/Open-Jev",
+        "configs": CONFIGS,
+        "used_splits": ["train", "validation"],
+        "excluded_splits": ["calibration", "test", "ood"],
+        "excluded_overlapping_configs": ["release-v2-redistributable", "browser-drone-expansion-v1-redistributable"],
+        "train_stats": dict(train_stats),
+        "validation_stats": dict(val_stats),
+        "groups_shared_by_config": overlap,
+        "validation_exact_duplicates_removed": before-len(validation),
+        "converted_train_rows": len(train),
+        "converted_validation_rows": len(validation),
+        "model_inputs": ["state", "question", "options"],
+        "privileged_metadata_excluded_from_model_input": ["metadata_json", "record_json", "target", "group_id", "split", "source"],
+    }
+    json.dump(report, open("data/openjev_conversion_report.json", "w"), indent=2)
+    print(json.dumps({"train": len(train), "validation": len(validation),
+                      "overlap": overlap, "train_kinds": dict(train_stats),
+                      "dev_kinds": dict(val_stats)}, indent=2))
+
+
+if __name__ == "__main__":
+    main()