| """v2 step 3: write the deduplicated, split release by copying stored rows byte for byte. |
| |
| Every kept triplet (fold from <split_dir>/<subset>/{train,val,test}.parquet) is written to |
| <out>/<subset>/<fold>/<subset>_<fold>_<NNNN>.aselmdb |
| in ascending ms_id order (R, S, P rows of a triplet adjacent), at most <per_shard> triplets per file. The files are |
| cut on the full split list, and then the BROKEN triplets are left out, so lemat_train_0213 and lemat_train_0479 |
| hold per_shard - 1 triplets and the other files do not change. Rows are NOT |
| re-serialised: the zlib-compressed JSON value stored in the SciLM shard is copied unchanged under a new LMDB key |
| ("1".."3n"; the id is not part of the stored value), then "nextid" = 3n+1 is written exactly as ase_db_backends does. |
| Each file is written as <name>.tmp and renamed only after its transaction committed. |
| usage: v2_write.py <scilm_root> <scilm_index_dir> <split_dir> <out_root> [per_shard=50000] [workers=48] [subsets] |
| """ |
| import glob, os, sys, zlib, json |
| import numpy as np, pyarrow.parquet as pq |
| from ase.io.jsonio import encode |
| from multiprocessing import Pool |
|
|
| FOLDS = ["train", "val", "test"] |
| src_root, idx_dir, split_dir, out = sys.argv[1:5] |
| per = int(sys.argv[5]) if len(sys.argv) > 5 else 50000; nw = int(sys.argv[6]) if len(sys.argv) > 6 else 48 |
| SUBS = sys.argv[7].split(",") if len(sys.argv) > 7 else ["lemat", "mp20bat", "oc20", "oc22"] |
| |
| |
| BROKEN = [35584423, 79800988] |
|
|
|
|
| def load_index(s): |
| Z = [np.load(f) for f in sorted(glob.glob(f"{idx_dir}/{s}__*.npz"))] |
| shards = [str(z["shard"]) for z in Z] |
| ms = np.concatenate([z["ms"] for z in Z]); key = np.concatenate([z["key"] for z in Z]) |
| fi = np.concatenate([np.full(len(z["ms"]), i, np.int32) for i, z in enumerate(Z)]) |
| o = np.argsort(ms); ms, key, fi = ms[o], key[o], fi[o] |
| assert (np.diff(ms) > 0).all(), f"{s}: repeated ms_id in the source" |
| return ms, key, fi, shards |
|
|
|
|
| def plan(): |
| jobs = [] |
| for s in SUBS: |
| ms, key, fi, shards = load_index(s) |
| for f in FOLDS: |
| fr = np.sort(np.asarray(pq.read_table(f"{split_dir}/{s}/{f}.parquet").column("ms_id"))) |
| sad = fr[fr % 3 == 1] |
| assert np.array_equal(fr, np.sort(np.concatenate([sad - 1, sad, sad + 1]))), f"{s}/{f}: incomplete triplets" |
| pos = np.searchsorted(ms, fr); assert (pos < len(ms)).all() and np.array_equal(ms[pos], fr), f"{s}/{f}: ms_id missing in source" |
| n = (len(sad) + per - 1) // per |
| for k in range(n): |
| rows = pos[3 * k * per: 3 * (k + 1) * per] |
| rows = rows[~np.isin(ms[rows] // 3, np.array(BROKEN) // 3)] |
| name = f"{s}/{f}/{s}_{f}_{k:04d}.aselmdb" |
| jobs.append((name, [shards[i] for i in range(len(shards))], fi[rows], key[rows], ms[rows])) |
| return jobs |
|
|
|
|
| def work(job): |
| import lmdb |
| name, shards, fi, key, ms = job |
| dst = f"{out}/{name}" |
| if os.path.exists(dst): return name, len(ms), "exists" |
| os.makedirs(os.path.dirname(dst), exist_ok=True) |
| vals = [None] * len(ms) |
| for f in np.unique(fi): |
| env = lmdb.open(f"{src_root}/{shards[f]}", subdir=False, readonly=True, lock=False, readahead=False, meminit=False) |
| sel = np.where(fi == f)[0]; sel = sel[np.argsort(key[sel])] |
| with env.begin(buffers=False) as t: |
| for i in sel: |
| v = t.get(str(int(key[i])).encode("ascii")); assert v is not None, (name, shards[f], key[i]); vals[i] = v |
| env.close() |
| tmp = dst + ".tmp" |
| for p in (tmp, tmp + "-lock"): |
| if os.path.exists(p): os.remove(p) |
| env = lmdb.open(tmp, subdir=False, map_size=2 ** 41, meminit=False, lock=False, sync=True) |
| with env.begin(write=True) as t: |
| for i, v in enumerate(vals): |
| assert t.put(str(i + 1).encode("ascii"), v, overwrite=False) |
| t.put(b"nextid", zlib.compress(bytes(encode(len(vals) + 1), "utf-8")), overwrite=False) |
| env.sync(True); env.close() |
| os.rename(tmp, dst) |
| return name, len(ms), "written" |
|
|
|
|
| if __name__ == "__main__": |
| jobs = plan(); jobs.sort(key=lambda j: -len(j[4])) |
| print(f"{len(jobs)} output shards, {sum(len(j[4]) for j in jobs)} rows", flush=True) |
| man = [(j[0], len(j[4]) // 3, int(j[4][0]), int(j[4][-1])) for j in sorted(jobs)] |
| os.makedirs(out, exist_ok=True) |
| if len(SUBS) == 4: |
| with open(f"{out}/.manifest.tsv", "w") as fh: |
| fh.write("file\ttriplets\tfirst_ms_id\tlast_ms_id\n") |
| for m in man: fh.write("\t".join(map(str, m)) + "\n") |
| with Pool(nw) as pool: |
| for n, (name, r, st) in enumerate(pool.imap_unordered(work, jobs), 1): |
| print(f" {n}/{len(jobs)} {name}: {r} rows {st}", flush=True) |
|
|
