| """Apply the decisions to LeMat-Bulk compatible_pbe and write the fixed shards plus the audit table. |
| |
| usage: build_fixed.py WORK OUT |
| """ |
| import sys, json, glob, os, collections, numpy as np, pandas as pd, pyarrow as pa, pyarrow.parquet as pq |
| from pathlib import Path |
|
|
| W, OUT = Path(sys.argv[1]), Path(sys.argv[2]) |
| SRC = Path(os.path.expanduser("~/.cache/huggingface/hub/datasets--LeMaterial--LeMat-Bulk/snapshots/" |
| "0dc17eea904b860ad7288141e9870f67f8e6bb2c/compatible_pbe")) |
|
|
| sys.path.insert(0, str(Path(__file__).parent)) |
| from tsutil import lemat_time |
| dec = pd.read_parquet(W / "decisions.parquet").set_index("immutable_id") |
| task_time = {t["task_id"]: t.get("last_updated") for t in json.load(open(W / "tasks_meta.json"))} |
| rep = {} |
| for line in open(W / "replacements.jsonl"): |
| p = json.loads(line) |
| if p["action"] != "control": |
| rep[p["immutable_id"]] = p |
| joined = pd.read_parquet(W / "joined.parquet").drop_duplicates("immutable_id") |
| ml = ["orb_direct_20", "orb_conserv_inf", "uma", "mace_mp", "mace_omat"] |
|
|
| |
| |
| |
| RECOVERY = Path(os.path.expanduser("~/.local/share/wyformer/cache/mp_forces_recovery/runs/full/results.parquet")) |
| recovered = pd.read_parquet(RECOVERY, columns=["immutable_id", "group", "status", "forces", "stress"]) |
| recovered = recovered[(recovered.group == "missing") & recovered.status.str.startswith("exact")].set_index("immutable_id") |
| |
| steps = {} |
| if (W / "s3_steps" / "steps.jsonl").exists(): |
| for line in open(W / "s3_steps" / "steps.jsonl"): |
| d = json.loads(line) |
| if d["ok"]: |
| steps[d["task_id"]] = d |
| for i, p in rep.items(): |
| st = steps.get(p["task_id"]) |
| if st is not None: |
| if not p.get("forces"): |
| p["forces"] = [st["forces"][j] for j in p["perm"]]; p["forces_source"] = "last_ionic_step" |
| if not p.get("stress"): |
| p["stress"] = st["stress"]; p["stress_source"] = "last_ionic_step" |
| print("replacements filled from the last ionic step:", sum("forces_source" in p for p in rep.values()), |
| "| still without forces:", sum(not p.get("forces") for p in rep.values())) |
|
|
| |
| |
| from removal_causes import CAUSES, UNEXPLAINED, POTCAR_OFFSETS |
| ident = pd.read_parquet(W / "identify.parquet").set_index("immutable_id") |
| x = joined.set_index("immutable_id") |
| remove, cause, flagged = {}, {}, {} |
| for i, r in dec[dec.action == "remove"].iterrows(): |
| pots = [p for p in str(ident.at[i, "lemat_potcars"]).split(",") if p in POTCAR_OFFSETS] |
| if pots: |
| remove[i] = "nonstandard_potcar" |
| cause[i] = "; ".join(f"{p}: measured offset +{POTCAR_OFFSETS[p][0]:.3f} eV per atom of that element " |
| f"vs the standard POTCAR on {POTCAR_OFFSETS[p][1]} same-structure pairs" for p in pots) \ |
| + "; MP deprecated the material and has no valid replacement calculation" |
| else: |
| flagged[i] = ("mp_material_deprecated_no_stated_reason", |
| "MP deprecated the material without a stated reason; standard POTCARs and U; kept") |
| for i, why in CAUSES.items(): |
| remove[i] = "calculation_defect"; cause[i] = why |
| for i, why in UNEXPLAINED.items(): |
| flagged[i] = ("unexplained_mlip_gap", "> 0.5 eV/atom below all five MLIPs; " + why + "; kept") |
| print("removals:", pd.Series(remove).value_counts().to_dict(), "flagged:", len(flagged)) |
|
|
| def replacement_cause(i, r): |
| """Why the upstream DFT record was replaced, from the MP provenance of row i.""" |
| t = ident.loc[i] |
| if r.grp == "unidentified": |
| return "upstream energy matches no GGA/GGA+U task MP still serves for this material" |
| if r.grp == "live_other_task": |
| return (f"upstream task {t.lemat_task} is live but {abs(r.old_vs_mlip):.2f} eV/atom from the MLIP median; " |
| f"MP's task {r.new_task} on the same structure is within {abs(r.new_vs_mlip):.2f}") |
| bits = [f"upstream task {t.lemat_task} ({t.lemat_calc_type}, batch {t.lemat_batch}) is deprecated by MP" |
| if t.lemat_task_deprecated else f"upstream task {t.lemat_task} ({t.lemat_calc_type})"] |
| if isinstance(t.mp_run, str) and t.lemat_run != t.mp_run: |
| bits.append(f"it is {t.lemat_run} where MP's mixing scheme uses {t.mp_run}") |
| old_p, new_p = set(str(t.lemat_potcars).split(",")), set(str(t.mp_potcars).split(",")) |
| if isinstance(t.mp_potcars, str) and old_p != new_p: |
| bits.append("non-standard POTCAR " + ", ".join(sorted(old_p - new_p))) |
| hu = lambda h: {k: v for k, v in (json.loads(h) or {}).items() if v} if isinstance(h, str) else {} |
| if t.lemat_run == t.mp_run and hu(t.lemat_task_hubbards) != hu(t.mp_hubbards): |
| bits.append(f"U values {hu(t.lemat_task_hubbards)} vs MP's {hu(t.mp_hubbards)}") |
| return "; ".join(bits) |
|
|
|
|
| |
| aud = [] |
| for i, p in rep.items(): |
| if i in remove: |
| continue |
| r = dec.loc[i] |
| aud.append(dict(immutable_id=i, change=p["action"], reason=r.grp, cause=replacement_cause(i, r), |
| old_energy=float(x.at[i, "energy"]), |
| new_energy=p["energy"], nsites=int(x.at[i, "nsites"]), new_nsites=len(p["species"]), old_mp_task=r.lemat_task if r.grp != "unidentified" else None, |
| old_calc_type=r.lemat_calc_type if r.grp != "unidentified" else None, old_batch=r.lemat_batch if r.grp != "unidentified" else None, |
| new_mp_task=p["task_id"], new_calc_type=r.new_calc_type, geometry_match=r.geo, |
| forces_source=p.get("forces_source", "output") if p.get("forces") else None, |
| mlip_median_energy_per_atom=r.mlip_epa)) |
| for i, why in remove.items(): |
| r = dec.loc[i] if i in dec.index else None |
| aud.append(dict(immutable_id=i, change="removed", reason=why, cause=cause[i], |
| old_energy=float(x.at[i, "energy"]) if i in x.index else np.nan, new_energy=np.nan, |
| nsites=int(x.at[i, "nsites"]) if i in x.index else -1, |
| old_mp_task=None if r is None else r.lemat_task, old_calc_type=None if r is None else r.lemat_calc_type, |
| old_batch=None if r is None else r.lemat_batch, new_mp_task=None, new_calc_type=None, geometry_match=None, |
| mlip_median_energy_per_atom=float(x.at[i, "epa"] - x.at[i, "d_med"]) if i in x.index else np.nan)) |
| for i, (why, note) in flagged.items(): |
| r = dec.loc[i] if i in dec.index else None |
| aud.append(dict(immutable_id=i, change="kept_flagged", reason=why, cause=note, |
| old_energy=float(x.at[i, "energy"]), new_energy=float(x.at[i, "energy"]), |
| nsites=int(x.at[i, "nsites"]), old_mp_task=None if r is None else r.lemat_task, |
| old_calc_type=None if r is None else r.lemat_calc_type, old_batch=None if r is None else r.lemat_batch, |
| new_mp_task=None, new_calc_type=None, geometry_match=None, |
| mlip_median_energy_per_atom=float(x.at[i, "epa"] - x.at[i, "d_med"]))) |
| for i, r in dec[dec.action == "keep_stale_mlip_consistent"].iterrows(): |
| if i not in remove: |
| aud.append(dict(immutable_id=i, change="kept_flagged", reason=r.grp, cause="stale MP task with no valid replacement; agrees with the MLIPs; kept", old_energy=float(x.at[i, "energy"]), |
| new_energy=float(x.at[i, "energy"]), nsites=int(x.at[i, "nsites"]), old_mp_task=r.lemat_task, |
| old_calc_type=r.lemat_calc_type, old_batch=r.lemat_batch, new_mp_task=None, new_calc_type=None, |
| geometry_match=None, mlip_median_energy_per_atom=r.mlip_epa)) |
| for i in recovered.index: |
| if i in rep or i in remove or i not in x.index: |
| continue |
| aud.append(dict(immutable_id=i, change="forces_stress_added", reason="upstream_empty", |
| cause=("forces and stress_tensor were empty upstream; taken from the last ionic step of " |
| "the same MP task, matched to the upstream energy and geometry " |
| "(scripts/recover_mp_forces.py)"), |
| old_energy=float(x.at[i, "energy"]), new_energy=float(x.at[i, "energy"]), |
| nsites=int(x.at[i, "nsites"]), forces_source="last_ionic_step")) |
| aud = pd.DataFrame(aud) |
| |
| dup = aud.immutable_id.duplicated(keep=False) |
| both = set(aud.loc[dup & aud.change.eq("forces_stress_added"), "immutable_id"]) |
| m = aud.immutable_id.isin(both) & aud.change.eq("kept_flagged") |
| aud.loc[m, "forces_source"] = "last_ionic_step" |
| aud.loc[m, "cause"] = aud.loc[m, "cause"] + "; forces and stress_tensor (empty upstream) added from the last ionic step of the same MP task" |
| aud = aud[~(aud.immutable_id.isin(both) & aud.change.eq("forces_stress_added"))].reset_index(drop=True) |
| assert not aud.immutable_id.duplicated().any() |
| geo = pd.read_parquet(W / "rs_geo.parquet").set_index("immutable_id") |
| m = aud.change.eq("replace_structure") |
| aud.loc[m, "geometry_match"] = aud.loc[m, "immutable_id"].map(geo.geometry_match) |
| aud["volume_change"] = aud.immutable_id.map(geo.dvol) |
| aud["old_energy_per_atom"] = aud.old_energy / aud.nsites |
| aud["new_nsites"] = aud.new_nsites.fillna(aud.nsites).astype(int) |
| aud["new_energy_per_atom"] = aud.new_energy / aud.new_nsites |
| (OUT / "audit").mkdir(parents=True, exist_ok=True) |
| aud.to_parquet(OUT / "audit" / "changes.parquet", index=False) |
| print(aud.groupby(["change", "reason"]).size()) |
|
|
| |
| (OUT / "compatible_pbe").mkdir(parents=True, exist_ok=True) |
| files = sorted(SRC.glob("*.parquet")) |
| n_in = n_out = n_rep = n_recovered = 0 |
| for fn in files: |
| t = pq.read_table(fn) |
| schema = t.schema |
| ids = t.column("immutable_id").to_pylist() |
| keep = np.array([i not in remove for i in ids]) |
| hit = [k for k, i in enumerate(ids) if i in rep and i not in remove] |
| if hit: |
| cols = {name: t.column(name).to_pylist() for name in |
| ("energy", "forces", "stress_tensor", "magnetic_moments", "total_magnetization", "dos_ef", |
| "last_modified", "lattice_vectors", "cartesian_site_positions", "species_at_sites", |
| "nsites", "chemical_formula_descriptive")} |
| for k in hit: |
| p = rep[ids[k]] |
| assert set(p["species"]) == set(cols["species_at_sites"][k]), ids[k] |
| if len(p["species"]) != cols["nsites"][k]: |
| counts = collections.Counter(p["species"]) |
| cols["nsites"][k] = len(p["species"]) |
| cols["chemical_formula_descriptive"][k] = " ".join(f"{e}{counts[e]}" for e in sorted(counts)) |
| cols["energy"][k] = p["energy"] |
| cols["lattice_vectors"][k] = p["lattice"] |
| cols["cartesian_site_positions"][k] = p["xyz"] |
| cols["species_at_sites"][k] = p["species"] |
| cols["forces"][k] = p["forces"] if p["forces"] is not None else [] |
| cols["stress_tensor"][k] = p["stress"] if p["stress"] is not None else [] |
| magmom = [0.0 if m is None else m for m in p["magmom"]] if p["magmom"] and any(m is not None for m in p["magmom"]) else [] |
| cols["magnetic_moments"][k] = magmom |
| |
| cols["total_magnetization"][k] = float(sum(magmom)) if magmom else p["total_magnetization"] |
| cols["dos_ef"][k] = p["efermi"] |
| |
| cols["last_modified"][k] = lemat_time(task_time.get(p["task_id"]) or p["last_updated"]) |
| for name, values in cols.items(): |
| idx = schema.get_field_index(name) |
| t = t.set_column(idx, schema.field(name), pa.array(values, type=schema.field(name).type)) |
| n_rep += len(hit) |
| |
| rec_hit = [k for k, i in enumerate(ids) if i in recovered.index and i not in rep and i not in remove] |
| if rec_hit: |
| forces = t.column("forces").to_pylist(); stress = t.column("stress_tensor").to_pylist() |
| for k in rec_hit: |
| r = recovered.loc[ids[k]] |
| if not forces[k]: |
| forces[k] = [list(map(float, f)) for f in r.forces] |
| if not stress[k]: |
| stress[k] = [list(map(float, row)) for row in r.stress] |
| for name, values in (("forces", forces), ("stress_tensor", stress)): |
| idx = schema.get_field_index(name) |
| t = t.set_column(idx, schema.field(name), pa.array(values, type=schema.field(name).type)) |
| n_recovered += len(rec_hit) |
| t = t.filter(pa.array(keep)) |
| n_in += len(ids); n_out += t.num_rows |
| pq.write_table(t.replace_schema_metadata(schema.metadata), OUT / "compatible_pbe" / fn.name, |
| compression="snappy", row_group_size=20000) |
| print(fn.name, len(ids), "->", t.num_rows, flush=True) |
| print(f"rows {n_in} -> {n_out}; replaced {n_rep}; removed {n_in - n_out}; forces/stress recovered for {n_recovered} untouched rows") |
|
|
