uploaded upet

models/equiformerv2/equiformer_v2/datasets/custom_data.py

@@ -41,7 +41,7 @@ class LargeDFTDataset(Dataset):
         self.normalize = normalize
 
         # dset_root = Environment.dset_path
-        dset_root = Path("/home/x_pavme/experiments/dft-training/catalyst/tetrasphere/tetrasphere/datasets/CO2_Ti2C-MXene")
+        dset_root = Path("")
         # split_name = f"{partition}"
         # file_name = dset_root / "" / (split_name + ".npy")
 

models/upet/upet/README.md

@@ -0,0 +1,31 @@
+Install the requirements:
+
+` pip install upet `
+
+To evaluate the models, run
+
+for UPET cons. 2.9M
+```
+python eval_upet_pt.py \
+  --xyz ../../datasets/xyz/testdata.xyz \
+  --pt-path runs/seed42_upet_perstr_300ep_bs8_1e-4_lf5.pt \
+  --forces-key forces \
+  --progress
+```
+
+for UPET non-cons. 3.0M
+```
+python eval_upet_noncon_mtt.py \
+  --xyz ../../datasets/xyz/testdata.xyz \
+  --pt-path runs/seed42_upet_noncon_300ep_bs8_1e-4_lf5.pt \
+  --forces-key forces 
+```
+
+for PET pretrained mad-s 25.9M
+```
+python eval_upet_pt.py \
+  --xyz ../../datasets/xyz/testdata.xyz \
+  --pt-path runs/seed42_pet-mad-s_perstr_100ep_bs8_1e-4_lf5.pt \
+  --forces-key forces \
+  --progress
+```

models/upet/upet/eval_upet_noncon_mtt.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Evaluate a *non-conservative* UPET metatrain-exported model.pt using `mtt eval`.
+
+For example:
+
+python eval_upet_noncon_mtt.py \
+  --xyz ../../datasets/xyz/testdata.xyz \
+  --pt-path runs/seed42_upet_noncon_300ep_bs8_1e-4_lf5.pt \
+  --forces-key forces 
+
+"""
+
+from __future__ import annotations
+import argparse
+import os
+import subprocess
+from pathlib import Path
+import yaml
+
+
+def run(cmd: list[str], cwd: str | None = None, env: dict | None = None) -> None:
+    env2 = dict(os.environ)
+    if env:
+        env2.update(env)
+    print("\n$ " + " ".join(cmd))
+    subprocess.run(cmd, cwd=cwd, env=env2, check=True)
+
+
+def abs_path(p: str) -> str:
+    return str(Path(p).expanduser().resolve())
+
+
+def write_eval_yaml(
+    path: Path,
+    *,
+    xyz_path: str,
+    length_unit: str,
+    energy_key: str,
+    energy_unit: str,
+    force_key: str,
+    force_unit: str,
+) -> None:
+    cfg = {
+        "systems": {"read_from": xyz_path, "length_unit": length_unit},
+        "targets": {
+            "energy": {"key": energy_key, "unit": energy_unit, "forces": "off"},
+            "non_conservative_forces": {
+                "key": force_key,
+                "quantity": "force",
+                "unit": force_unit,
+                "type": {"cartesian": {"rank": 1}},
+                "per_atom": True,
+            },
+        },
+    }
+    path.write_text(yaml.safe_dump(cfg, sort_keys=False))
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Evaluate non-conservative UPET/PET model.pt with mtt eval.")
+    ap.add_argument("--pt-path", required=True, help="Path to metatrain exported model.pt")
+    ap.add_argument("--xyz", required=True, help="Path to xyz/extxyz dataset with labels")
+
+    ap.add_argument("--energy-key", default="energy", help="Energy label key in xyz headers (atoms.info)")
+    ap.add_argument("--energy-unit", default="eV")
+    ap.add_argument("--forces-key", default="forces", help="Direct-force label key in xyz arrays (atoms.arrays)")
+    ap.add_argument("--force-unit", default="eV/angstrom", help="Force unit string for metatrain")
+
+    ap.add_argument("--length-unit", default="angstrom", choices=["angstrom", "Angstrom"])
+    ap.add_argument("--batch-size", type=int, default=8)
+    ap.add_argument("--out-xyz", default=None, help="Optional output xyz path to write predictions (mtt eval -o)")
+    ap.add_argument("--extensions", default=None, help="Optional extensions/ folder (mtt eval -e)")
+    ap.add_argument("--work-dir", default="mtt_eval_noncon", help="Directory to run in (contains eval.yaml + outputs/)")
+
+    ap.add_argument("--no-wandb", action="store_true", help="Disable wandb (sets WANDB_MODE=disabled)")
+    args = ap.parse_args()
+
+    work = Path(args.work_dir).expanduser().resolve()
+    work.mkdir(parents=True, exist_ok=True)
+
+    eval_yaml = work / "eval_noncon.yaml"
+    write_eval_yaml(
+        eval_yaml,
+        xyz_path=abs_path(args.xyz),
+        length_unit=args.length_unit,
+        energy_key=args.energy_key,
+        energy_unit=args.energy_unit,
+        force_key=args.forces_key,
+        force_unit=args.force_unit,
+    )
+
+    env = {}
+    if args.no_wandb:
+        env["WANDB_MODE"] = "disabled"
+        env["WANDB_SILENT"] = "true"
+
+    cmd = ["mtt", "eval", abs_path(args.pt_path), str(eval_yaml)]
+    cmd += ["-b", str(args.batch_size)]
+    if args.extensions:
+        cmd += ["-e", abs_path(args.extensions)]
+    if args.out_xyz:
+        cmd += ["-o", abs_path(args.out_xyz)]
+
+    run(cmd, cwd=str(work), env=env)
+    print("\nDone. metatrain wrote logs under:", str(work / "outputs"))
+
+
+if __name__ == "__main__":
+    main()

models/upet/upet/eval_upet_pt.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+python eval_upet_pt.py \
+  --xyz ../../datasets/xyz/testdata.xyz \
+  --pt-path runs/seed42_upet_perstr_300ep_bs8_1e-4_lf5.pt \
+  --forces-key forces \
+  --progress
+
+python eval_upet_pt.py \
+  --xyz ../../datasets/xyz/testdata.xyz \
+  --pt-path runs/seed42_pet-mad-s_perstr_100ep_bs8_1e-4_lf5.pt \
+  --forces-key forces \
+  --progress
+
+"""
+
+from __future__ import annotations
+import argparse
+from pathlib import Path
+import math
+import numpy as np
+import torch
+from tqdm import tqdm
+from ase.io import read
+from ase.atoms import Atoms
+
+
+def get_ref_energy(a: Atoms) -> float:
+    # Prefer calculator energy if present
+    if getattr(a, "calc", None) is not None:
+        try:
+            return float(a.get_potential_energy())
+        except Exception:
+            pass
+    # Fall back to common info keys
+    for k in ("energy", "energy_per_structure", "energy_total", "free_energy", "E", "Energy"):
+        if k in getattr(a, "info", {}):
+            return float(a.info[k])
+    raise KeyError("No reference energy found (no calculator energy and no known info key).")
+
+
+def get_ref_forces(a: Atoms, forces_key: str) -> np.ndarray:
+    if forces_key in getattr(a, "arrays", {}):
+        return np.asarray(a.arrays[forces_key], dtype=float)
+    if "forces" in getattr(a, "arrays", {}):
+        return np.asarray(a.arrays["forces"], dtype=float)
+    # calculator fallback
+    if getattr(a, "calc", None) is not None:
+        try:
+            return np.asarray(a.get_forces(), dtype=float)
+        except Exception:
+            pass
+    raise KeyError(f"No reference forces found (arrays missing '{forces_key}'/'forces' and no calc forces).")
+
+
+def compute_metrics(records):
+    # records: list of dict with dE (float), natoms (int), dF (np array Nx3)
+    total_force_components = 0.0
+    total_systems = 0.0
+    total_atoms = 0.0
+
+    sum_abs_dF = 0.0
+    sum_sq_dF = 0.0
+
+    sum_abs_dE = 0.0
+    sum_sq_dE = 0.0
+
+    sum_abs_dE_per_atom = 0.0
+    sum_sq_dE_per_atom = 0.0
+
+    for r in records:
+        n = float(r["natoms"])
+        total_systems += 1.0
+        total_atoms += n
+        total_force_components += 3.0 * n
+
+        dE = float(r["dE"])
+        abs_dE = abs(dE)
+        sum_abs_dE += abs_dE
+        sum_sq_dE += dE * dE
+
+        dE_pa = dE / n
+        sum_abs_dE_per_atom += abs(dE_pa)
+        sum_sq_dE_per_atom += dE_pa * dE_pa
+
+        dF = r["dF"].reshape(-1)  # 3N
+        sum_abs_dF += float(np.abs(dF).sum())
+        sum_sq_dF += float((dF * dF).sum())
+
+    mae_F = sum_abs_dF / total_force_components if total_force_components > 0 else float("nan")
+    rmse_F = math.sqrt(sum_sq_dF / total_force_components) if total_force_components > 0 else float("nan")
+
+    mae_E_sys = sum_abs_dE / total_systems if total_systems > 0 else float("nan")
+    rmse_E_sys = math.sqrt(sum_sq_dE / total_systems) if total_systems > 0 else float("nan")
+
+    mae_E_atom_weighted = sum_abs_dE / total_atoms if total_atoms > 0 else float("nan")
+    rmse_E_atom_weighted = math.sqrt(sum_sq_dE / total_atoms) if total_atoms > 0 else float("nan")
+
+    # standard metric: average over systems of |dE|/N, RMSE over systems of (dE/N)
+    mae_E_atom_mace = sum_abs_dE_per_atom / total_systems if total_systems > 0 else float("nan")
+    rmse_E_atom_mace = math.sqrt(sum_sq_dE_per_atom / total_systems) if total_systems > 0 else float("nan")
+
+    return {
+        "MAE(F components)": mae_F,
+        "MAE(E per system)": mae_E_sys,
+        "MAE(E per atom, weighted)": mae_E_atom_weighted,
+        "MAE(E per atom)": mae_E_atom_mace,
+        "RMSE(F components)": rmse_F,
+        "RMSE(E per system)": rmse_E_sys,
+        "RMSE(E per atom, weighted)": rmse_E_atom_weighted,
+        "RMSE(E per atom)": rmse_E_atom_mace,
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--xyz", required=True, help="Path to extxyz dataset")
+    ap.add_argument("--pt-path", required=True, help="Path to metatrain exported model.pt")
+    ap.add_argument("--forces-key", default="forces_mt", help="Reference forces key in ASE arrays (default: forces_mt)")
+    ap.add_argument("--index", default=":", help="ASE index selector (default ':')")
+    ap.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    ap.add_argument("--batch-size", type=int, default=1, help="Kept for CLI compatibility; evaluation is per-structure.")
+    ap.add_argument("--progress", action="store_true", help="Show tqdm progress bar")
+    args = ap.parse_args()
+
+    # Import MetatomicCalculator lazily for clearer error messages
+    try:
+        from metatomic.torch.ase_calculator import MetatomicCalculator
+    except Exception as e:
+        raise SystemExit(
+            "Could not import MetatomicCalculator. Ensure metatomic/metatensor is installed in this env.\n"
+            f"Original import error: {e}"
+        )
+
+    calc = MetatomicCalculator(model=args.pt_path, device=args.device)
+
+    atoms_list = read(args.xyz, index=args.index)
+    if isinstance(atoms_list, Atoms):
+        atoms_list = [atoms_list]
+
+    total = len(atoms_list)
+    records = []
+
+    it = atoms_list
+    if args.progress:
+        it = tqdm(atoms_list, desc="Eval (UPET local .pt)", dynamic_ncols=True)
+
+    for i, atoms in enumerate(it):
+        nat = len(atoms)
+        ref_E = get_ref_energy(atoms)
+        ref_F = get_ref_forces(atoms, args.forces_key)
+
+        # Predict
+        a = atoms.copy()
+        a.calc = calc
+        pred_E = float(a.get_potential_energy())
+        pred_F = np.asarray(a.get_forces(), dtype=float)
+
+        if pred_F.shape != ref_F.shape:
+            raise ValueError(f"Force shape mismatch pred {pred_F.shape} vs ref {ref_F.shape}")
+
+        dE = pred_E - ref_E
+        dF = pred_F - ref_F
+
+        records.append({"dE": dE, "dF": dF, "natoms": nat})
+
+    metrics = compute_metrics(records)
+
+    print(f"Total systems in file:\t\t{total}")
+    print(f"Evaluated systems:\t\t{len(records)}")
+
+    for k, v in metrics.items():
+        print(f"{k:28s} {v:.6f}")
+
+if __name__ == "__main__":
+    main()

models/upet/upet/runs/seed42_pet-mad-s_perstr_100ep_bs8_1e-4_lf5.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de68285099c86b5fb6597272fba4a51c52de7b063a62bb51d63181482f2b24c6
+size 104103775

models/upet/upet/runs/seed42_upet_noncon_300ep_bs8_1e-4_lf5.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:540dd475c5af06d60ffeeed8f4283d73aa6416199995073b76e21113a1b832cd
+size 12238673

models/upet/upet/runs/seed42_upet_perstr_300ep_bs8_1e-4_lf5.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a1a4efeb218cc2a5627988b4d01581c260e6ff447e1ef502028eb1bc52750b9c
+size 11890135