File size: 10,662 Bytes
ee7b277 08191b7 ee7b277 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | #!/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()
|