MicrobeKG / bench_v3 /make_release.py
ZachGu's picture
updatev2
08191b7 verified
Raw History Blame Contribute Delete
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()