Download bench_v3/make_release.py from ZachGu/MicrobeKG: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/datasets/ZachGu/MicrobeKG/resolve/main/bench_v3/make_release.py
- Command line
-
hf download hf://datasets/ZachGu/MicrobeKG/bench_v3/make_release.py
-
curl -L -o make_release.py https://huggingface.co/datasets/ZachGu/MicrobeKG/resolve/main/bench_v3/make_release.py
10.7 kB
| #!/usr/bin/env python3 | |
| """Build the data part of the licence-aware MicrobeKG-Bench v3 release. | |
| Inputs are read-only; only --out is written. Graph triples and splits are stored as Parquet with stable entity and | |
| relation identifiers (never server-local row numbers). Triples supported only by CTD/HMDB are excluded; the | |
| full-context setting is represented by a rebuild recipe. Validation and test tables carry a `study_id` column (the | |
| evidence cluster used for study-macro MRR and the hierarchical bootstrap: first literature study of the pair, else its | |
| cohort group; for the external set, the BugSigDB study). `finalize_release.py` writes the manifest and checksums. | |
| Example: | |
| python make_release.py --bench bench2 --bench3 bench3 --external bench_ext --records records_v2.tsv \ | |
| --edges final_kg_edges.tsv --source-terms-json source_terms.json --source-terms-md SOURCE_TERMS.md --out out | |
| """ | |
| from __future__ import annotations | |
| import argparse, json, os, shutil | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| RESTRICTED = {"CTD", "HMDB"} | |
| SEEDS = [42, 123, 456, 789, 2024] | |
| SETTINGS = ["t1_pair", "t1_study", "t1_study_reveal", "t1_study_strict", "t1_study_ctx_open", "t1_temporal", | |
| "t1_temporal_nodis", "t1_cold_microbe", "t1_cold_disease"] | |
| V3 = ["t1_v3_strict_nocohort", "t1_v3_strict_nooverlap", "t1_v3_strict_nocooc", "t1_v3_temporal_nocooc", | |
| "t1_v3_temporal_dated", "t1_v3_p11_base", "t1_v3_p11_same", "t1_v3_p11_other"] | |
| PARTS = ["train", "valid", "test", "known_extra", "conflict", "negatives", "probe_positive", "random_control_positive"] | |
| COLS = ["head_id", "head_type", "relation", "tail_id", "tail_type"] | |
| def write_json(p, o): | |
| p.parent.mkdir(parents=True, exist_ok=True) | |
| p.write_text(json.dumps(o, ensure_ascii=False, indent=2) + "\n") | |
| def triples_df(x, ents, rels): | |
| names, types = ents.node_id.to_numpy(), ents.node_type.to_numpy() | |
| return pd.DataFrame({"head_id": names[x[:, 0]], "head_type": types[x[:, 0]], | |
| "relation": np.asarray(rels, dtype=object)[x[:, 1]], "tail_id": names[x[:, 2]], | |
| "tail_type": types[x[:, 2]]}) | |
| def write_split(raw, x, keep_codes, ents, rels, sd, seed, study_of): | |
| n = len(ents) | |
| for part in PARTS: | |
| vals = raw[part] if part in raw.files else np.array([], np.int32) | |
| rows = vals if vals.ndim == 2 else np.asarray(x[vals]) | |
| rows = (np.asarray([r for r in rows if tuple(map(int, r)) in keep_codes], np.int32).reshape((-1, 3)) | |
| if len(rows) else np.empty((0, 3), np.int32)) | |
| df = triples_df(rows, ents, rels) if len(rows) else pd.DataFrame(columns=COLS) | |
| if part in ("valid", "test"): | |
| code = rows[:, 0].astype(np.int64) * n + rows[:, 2] | |
| df["study_id"] = [study_of.get(int(c), "") for c in code] | |
| df.to_parquet(sd / f"seed_{seed}_{part}.parquet", index=False) | |
| elig = raw["candidate_eligible"] | |
| pd.DataFrame({"entity_index": np.flatnonzero(elig), "node_id": ents.node_id.to_numpy()[elig], | |
| "node_type": ents.node_type.to_numpy()[elig]}).to_parquet( | |
| sd / f"seed_{seed}_candidate_entities.parquet", index=False) | |
| np.savez_compressed(sd / f"seed_{seed}_aux.npz", **{k: raw[k] for k in raw.files if k.endswith("_eligible") or | |
| k in ("taxonomy_hop", "ontology_hop", "random_control")}) | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| for a in ["bench", "bench3", "external", "records", "edges", "source-terms-json", "source-terms-md", "out"]: | |
| ap.add_argument(f"--{a}", type=Path, required=True) | |
| args = ap.parse_args() | |
| out = args.out | |
| if out.exists(): | |
| raise SystemExit(f"{out} exists; choose a new output directory") | |
| out.mkdir(parents=True) | |
| b, b3, e = args.bench, args.bench3, args.external | |
| ents = pd.read_csv(b / "entities.tsv", sep="\t", dtype=str, keep_default_na=False) | |
| rels = json.loads((b / "relations.json").read_text()) | |
| x = np.load(b / "triples.npy") | |
| n, R = len(ents), len(rels) | |
| idx = {(t, i): j for j, t, i in ents[["entity_index", "node_type", "node_id"]].itertuples(index=False, name=None)} | |
| rix = {r: i for i, r in enumerate(rels)} | |
| code = lambda h, r, t: (h.astype(np.int64) * R + r) * n + t | |
| xcode = code(x[:, 0], x[:, 1], x[:, 2]) | |
| assert np.all(np.diff(xcode) > 0), "server triples must be sorted and unique" | |
| restricted = np.ones(len(x), bool) | |
| for df in pd.read_csv(args.edges, sep="\t", usecols=COLS + ["source"], dtype=str, keep_default_na=False, | |
| chunksize=500000): | |
| h = np.fromiter((idx[(a, c)] for a, c in zip(df.head_type, df.head_id)), np.int64, len(df)) | |
| t = np.fromiter((idx[(a, c)] for a, c in zip(df.tail_type, df.tail_id)), np.int64, len(df)) | |
| r = np.fromiter((rix[v] for v in df.relation), np.int64, len(df)) | |
| pos = np.searchsorted(xcode, code(h, r, t)) | |
| ok = np.fromiter((bool(set(s.split("|")) - RESTRICTED) for s in df.source), bool, len(df)) | |
| restricted[pos[ok]] = False | |
| keep = ~restricted | |
| removed = int(restricted.sum()) | |
| bd = out / "benchmark" | |
| (bd / "splits").mkdir(parents=True) | |
| ents.to_csv(bd / "entities.tsv", sep="\t", index=False) | |
| write_json(bd / "relations.json", rels) | |
| triples_df(x[keep], ents, rels).to_parquet(bd / "triples.parquet", index=False) | |
| pub = set(map(tuple, x[keep].tolist())) | |
| ps = pd.read_csv(b / "pair_support.tsv", sep="\t", dtype=str, keep_default_na=False) | |
| ps.to_parquet(bd / "pair_support.parquet", index=False) | |
| l1, c1 = ps.lit_studies.str.split(";").str[0], ps.cohort_studies.str.split(";").str[0] | |
| study_of = dict(zip(ps.code.astype(np.int64).tolist(), np.where(l1 != "", l1, c1).tolist())) | |
| pd.read_csv(b / "tested_null.tsv", sep="\t", dtype=str, keep_default_na=False).to_parquet( | |
| out / "tested_null.parquet", index=False) | |
| for setting in SETTINGS + V3: | |
| src_root = b3 if setting in V3 else b | |
| sd = bd / "splits" / setting | |
| sd.mkdir(parents=True, exist_ok=True) | |
| for seed in SEEDS: | |
| src = src_root / "splits" / setting / f"seed_{seed}" | |
| meta = json.loads(src.with_suffix(".json").read_text()) | |
| raw = np.load(src.with_suffix(".npz"), allow_pickle=False) | |
| write_split(raw, x, pub, ents, rels, sd, seed, study_of) | |
| write_json(sd / f"seed_{seed}.json", {**meta, "released_representation": "triple_parquet", | |
| "source_row_indices_not_released": True}) | |
| print(setting, "done", flush=True) | |
| # P1-1 pair sets (revealed same-study pairs, their matched subset, and the matched other-study reserve) | |
| pd_dir = bd / "p11_pairs" | |
| pd_dir.mkdir() | |
| names = ents.node_id.to_numpy() | |
| for seed in SEEDS: | |
| z = np.load(b3 / f"p11_pairs_seed{seed}.npz") | |
| frames = [pd.DataFrame({"set": k, "head_id": names[z[k] // n], "tail_id": names[z[k] % n]}) | |
| for k in ["revealed", "matched", "reserve"]] | |
| pd.concat(frames).to_parquet(pd_dir / f"seed_{seed}.parquet", index=False) | |
| write_json(bd / "variants_build_audit.json", json.loads((b3 / "build_audit.json").read_text())) | |
| write_json(bd / "t1_study_ctx_full_REBUILD_REQUIRED.json", { | |
| "setting": "t1_study_ctx_full", "status": "rebuild-required", | |
| "reason": "training context includes triples supported only by CTD/HMDB; source terms restrict redistribution", | |
| "script": "mkbench_build_v2.py in the code supplement", | |
| "inputs": "the audited graph and source permissions; not included"}) | |
| # external time-out set | |
| ext_x = np.load(e / "triples.npy", mmap_mode="r") | |
| ext_codes = set(map(tuple, ext_x.tolist())) | |
| exd = out / "external" | |
| exd.mkdir() | |
| shutil.copy2(e / "entities.tsv", exd / "entities.tsv") | |
| shutil.copy2(e / "relations.json", exd / "relations.json") | |
| ext = pd.read_csv(e / "external_pairs.tsv", sep="\t", dtype=str, keep_default_na=False) | |
| ext["study_id"] = ext.bsdb.str.split("/").str[0] # BugSigDB study (PMID- or DOI-keyed) | |
| ext.loc[ext.study_id.str.startswith("bsdb:10."), "pmid"] = "" # DOI-keyed studies have no PMID | |
| ext.to_parquet(exd / "external_pairs.parquet", index=False) | |
| ext_study = ext.groupby(ext.code.astype(np.int64)).study_id.first().to_dict() | |
| ents_e = pd.read_csv(e / "entities.tsv", sep="\t", dtype=str, keep_default_na=False) | |
| rels_e = json.loads((e / "relations.json").read_text()) | |
| sd = exd / "splits" / "t1_external" | |
| sd.mkdir(parents=True) | |
| for seed in SEEDS: | |
| src = e / "splits" / "t1_external" / f"seed_{seed}" | |
| raw = np.load(src.with_suffix(".npz"), allow_pickle=False) | |
| write_split(raw, ext_x, ext_codes, ents_e, rels_e, sd, seed, ext_study) | |
| write_json(sd / f"seed_{seed}.json", {**json.loads(src.with_suffix(".json").read_text()), | |
| "released_representation": "triple_parquet", | |
| "source_row_indices_not_released": True}) | |
| # record layer without personal-information columns | |
| rec = pd.read_csv(args.records, sep="\t", dtype=str, keep_default_na=False) | |
| pii = [c for c in rec.columns if c.lower() in {"authors", "author", "curator", "submittedby", "revision_editor", | |
| "email", "name", "location_of_subjects"}] | |
| rec = rec.drop(columns=pii, errors="ignore") | |
| (out / "records").mkdir() | |
| rec.to_parquet(out / "records" / "records_v2.parquet", index=False) | |
| write_json(out / "records" / "schema.json", {"columns": {c: {"dtype": "string", "personal_information": False, | |
| "source": "derived upstream record export"} | |
| for c in rec.columns}, "removed_columns": pii}) | |
| write_json(out / "SOURCE_TERMS.json", json.loads(args.source_terms_json.read_text())) | |
| shutil.copy2(args.source_terms_md, out / "SOURCE_TERMS.md") | |
| write_json(out / "build_info.json", {"ctd_hmdb_only_triples_removed": removed, "settings": SETTINGS + V3, | |
| "seeds": SEEDS, "graph_version": "microbekg-audited", | |
| "benchmark_version": "mkbench-v3"}) | |
| for root, dirs, files in os.walk(out): | |
| for d in dirs: | |
| os.chmod(Path(root) / d, 0o755) | |
| for f in files: | |
| os.chmod(Path(root) / f, 0o644) | |
| print(json.dumps({"out": str(out), "removed_ctd_hmdb_only": removed}), flush=True) | |
| if __name__ == "__main__": | |
| main() | |