File size: 13,502 Bytes
ce33d98 74e2a2e 14d44a6 ce33d98 14d44a6 ce33d98 14d44a6 ce33d98 74e2a2e ce33d98 14d44a6 ce33d98 14d44a6 ce33d98 14d44a6 ce33d98 74e2a2e ce33d98 74e2a2e ce33d98 74e2a2e ce33d98 74e2a2e ce33d98 74e2a2e | 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 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 | """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"]
# --- forces and stress that upstream (or a replacement task's output) left empty
# Untouched rows: scripts/recover_mp_forces.py matched LeMat's own task bit-exactly and took the
# values from its last ionic step, already in LeMat's site order.
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")
# Replacement tasks: the last ionic step, kept only when it is the task's output (s3_steps.py).
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()))
# --- removals, each with a calculation-level cause (removal_causes.py); nothing is removed for
# disagreeing with the MLIPs alone
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)
# --- audit table
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)
# a flagged row that also gained forces/stress keeps one audit entry: the flag, with the forces noted
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())
# --- rewrite the shards
(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
# LeMat's total_magnetization is the sum of the site moments (95% of control rows)
cols["total_magnetization"][k] = float(sum(magmom)) if magmom else p["total_magnetization"]
cols["dos_ef"][k] = p["efermi"]
# LeMat's last_modified is the API task's last_updated (98.5% of control rows)
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)
# untouched rows whose forces/stress upstream left empty: the recovered values
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")
|