#!/usr/bin/env python3 """MACE Δ-learning on B3LYP.""" from __future__ import annotations import argparse import hashlib import json import sys import warnings from datetime import datetime from pathlib import Path import numpy as np import torch from tqdm.auto import tqdm _CODE_TREE = Path(__file__).resolve().parents[1] sys.path.insert(0, str(_CODE_TREE)) from common.utils import ( CODE_ROOT, CONFIGS, DEFAULT_BATCH_SIZE, DEFAULT_CLIP_THRESHOLD, DEFAULT_LR, DEFAULT_TOTAL_STEPS, DEFAULT_WARMUP_STEPS, HARTREE2KCAL, DatasetWithBaseline, default_data_root, loss_weighted_mse, make_adafactor_cosine, make_name2baseline, name2baseline_indices, ) sys.path.insert(0, str(CODE_ROOT / "common")) import datasets as utils # noqa: E402 from ase.data import atomic_numbers as Z_OF # noqa: E402 from mace_delta.model import ( # noqa: E402 MACEDeltaB3LYPSkala, forward_reaction_batch_delta_b3lyp_skala, ) # Transition-metal GSCDB subset prefixes (dropped for the main-group protocol). TM_GSCDB_PREFIXES = ("3d4dIPSS", "CUAGAU", "DAPD", "MME", "MOBH", "ROST", "TMD", "MOR", "TMB") def resolve_rdb7_dir(data_root: Path) -> Path: for name in ("RDB7_new", "RDB7"): p = data_root / name if p.is_dir(): return p raise FileNotFoundError(f"Neither RDB7_new nor RDB7 found under {data_root}") def resolve_gscdb_info_root(data_root: Path, override: str = "") -> Path: import os cands = [] if override: cands.append(Path(override)) env = os.environ.get("GSCDB_ROOT", "").strip() if env: cands.append(Path(env)) cands += [ data_root / "GSCDB_gitclone" / "GSCDB", data_root / "GSCDB", ] for c in cands: if (c / "Info" / "DatasetEval.csv").is_file(): return c raise FileNotFoundError( "GSCDB Info/DatasetEval.csv not found. Pass --gscdb-root or set GSCDB_ROOT. Tried: " + ", ".join(str(c) for c in cands) ) def is_tm_gscdb_reaction_name(name: str) -> bool: s = str(name) if s.startswith(("pts_", "rts_", "rp_")) or "_" not in s: return False sub = s.rsplit("_", 1)[0] return any(sub.startswith(p) for p in TM_GSCDB_PREFIXES) def filter_main_group_gscdb(names: list[str]) -> list[str]: return [n for n in names if not is_tm_gscdb_reaction_name(n)] def filter_dataset_by_names(dataset, names): names_set = set(names) if hasattr(dataset, "df") and hasattr(dataset, "keys"): keep = [k for k in dataset.keys if k in names_set] dataset.keys = keep dataset.df = dataset.df.loc[keep].copy() return dataset if hasattr(dataset, "mol_paths"): dataset.mol_paths = [p for p in dataset.mol_paths if Path(p).stem in names_set] return dataset if hasattr(dataset, "paths"): dataset.paths = [p for p in dataset.paths if Path(p).stem in names_set] return dataset raise RuntimeError("Unsupported dataset type for filtering") def build_datasets( *, split_json: Path, data_root: Path, gscdb_root: Path, assets_dir: Path, gscdb_mol_folders: list[Path], main_group_only: bool, ): if not split_json.is_file(): raise FileNotFoundError(f"Split JSON not found: {split_json}") with open(split_json) as f: payload = json.load(f) splits = payload["splits"] if main_group_only: for key in ("gscdb_train", "gscdb_val"): before = len(splits[key]) splits[key] = filter_main_group_gscdb(list(splits[key])) print(f"{key}: {before} -> {len(splits[key])}") mol_dirs = [str(p) for p in gscdb_mol_folders] msr_mol, msr_atom = str(data_root / "MSR_TAE25" / "molecules"), str(data_root / "MSR_TAE25" / "atoms") rdb7 = str(resolve_rdb7_dir(data_root)) _g_train = utils.GSCDBDataset(gscdb_root=str(gscdb_root), mol_folders=mol_dirs) _g_val = utils.GSCDBDataset(gscdb_root=str(gscdb_root), mol_folders=mol_dirs) _msr_train = utils.MSRReactionDataset(msr_mol, msr_atom) _msr_val = utils.MSRReactionDataset(msr_mol, msr_atom) _rdb7_train = utils.ReactionDataset([rdb7]) _rdb7_val = utils.ReactionDataset([rdb7]) filter_dataset_by_names(_g_train, splits["gscdb_train"]) filter_dataset_by_names(_g_val, splits["gscdb_val"]) filter_dataset_by_names(_msr_train, splits["msr_train"]) filter_dataset_by_names(_msr_val, splits["msr_val"]) filter_dataset_by_names(_rdb7_train, splits["rdb7_train"]) filter_dataset_by_names(_rdb7_val, splits["rdb7_val"]) train_ds = utils.DatasetCompose([_g_train, _msr_train, _rdb7_train]) val_ds = utils.DatasetCompose([_g_val, _msr_val, _rdb7_val]) subset2baseline, msr_global, rdb7_global = make_name2baseline(assets_dir) idx_tr = name2baseline_indices(train_ds, subset2baseline, msr_global, rdb7_global) idx_va = name2baseline_indices(val_ds, subset2baseline, msr_global, rdb7_global) train_b = DatasetWithBaseline(train_ds, idx_tr) val_b = DatasetWithBaseline(val_ds, idx_va) print( "train_len:", len(train_b), "val_len:", len(val_b), "dropped_train_no_energy:", train_b.dropped_missing_energy, ) return train_b, val_b, mol_dirs def load_weights_filtered(model, ckpt_path: str, dev: torch.device, *, verbose: bool = False): try: ckpt = torch.load(ckpt_path, map_location=dev, weights_only=True) except Exception as e1: # noqa: BLE001 warnings.warn("falling back to weights_only=False for checkpoint load") ckpt = torch.load(ckpt_path, map_location=dev, weights_only=False) state = model.state_dict() filtered = {k: v for k, v in ckpt.items() if k in state and state[k].shape == v.shape} if verbose: for k in ckpt: if k not in filtered: print("skip", k) state.update(filtered) model.load_state_dict(state, strict=False) return model def _xc_b3lyp(mol: dict) -> float: if "E_xc_b3lyp" in mol: return float(mol["E_xc_b3lyp"]) if "E_xc_B3LYP" in mol: return float(mol["E_xc_B3LYP"]) raise KeyError("need E_xc_b3lyp or E_xc_B3LYP") def _molecule_uid_delta(mol: dict) -> str: payload = { "xyz": mol["xyz"], "E_unxc": float(mol["E_unxc"]), "hf_x": float(mol.get("hf_x", 0.0)), "d3bj_b3lyp": float(mol.get("d3bj_b3lyp", 0.0)), "E_xc_b3lyp": _xc_b3lyp(mol), } return hashlib.sha1(json.dumps(payload, sort_keys=True).encode("utf-8")).hexdigest() def _parse_xyz(xyz: str): elems, coords = [], [] for line in xyz.splitlines(): p = line.split() if len(p) != 4: continue elems.append(p[0]) coords.append([float(p[1]), float(p[2]), float(p[3])]) return elems, np.asarray(coords, dtype=np.float32) def rxn_molecules_table_delta(rxn: dict, molecules: dict, z_table): allowed_z = frozenset(z_table.zs) rec = {"name": str(rxn["name"]), "energy_kcal": float(rxn["energy"]), "mols": []} for mol in rxn["mols"].values(): for req in ("xyz", "E_unxc", "hf_x", "d3bj_b3lyp"): if req not in mol: return None try: _xc_b3lyp(mol) except KeyError: return None elems, _ = _parse_xyz(mol["xyz"]) if not elems or not all(Z_OF[e] in allowed_z for e in elems): return None uid = _molecule_uid_delta(mol) if uid not in molecules: elems_f, coords = _parse_xyz(mol["xyz"]) molecules[uid] = { "elements": elems_f, "coords": coords, "E_unxc": float(mol["E_unxc"]), "hf_x": float(mol["hf_x"]), "d3bj_b3lyp": float(mol["d3bj_b3lyp"]), "E_xc_b3lyp": _xc_b3lyp(mol), } rec["mols"].append({"mol_id": uid, "coeff": float(mol.get("coeff", 1.0))}) return rec @torch.no_grad() def eval_epoch(val_dataset, model, device, dtype): model.eval() maes, losses = [], [] for i in tqdm(range(len(val_dataset)), desc="val", leave=False): rxn = val_dataset[i] mols: dict = {} row = rxn_molecules_table_delta(rxn, mols, model.z_table) if row is None: continue pred_h, ref_h = forward_reaction_batch_delta_b3lyp_skala([row], mols, model, model.r_max, device, dtype) pred_k = pred_h * HARTREE2KCAL ref_k = ref_h * HARTREE2KCAL b = torch.as_tensor(float(rxn["baseline_mae"]), dtype=pred_k.dtype, device=pred_k.device) losses.append(loss_weighted_mse(pred_k, ref_k, b).item()) maes.append(torch.abs(pred_h - ref_h).item() * HARTREE2KCAL) return ( float(np.mean(maes)) if maes else float("nan"), float(np.mean(losses)) if losses else float("nan"), ) def train(args: argparse.Namespace) -> list[dict]: device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if device.type != "cuda": print("[WARN] CUDA not available; running on CPU", flush=True) dtype = torch.float32 data_root = Path(args.data_root).resolve() assets_dir = Path(args.assets_dir) split_json = Path(args.split_json) gscdb_root = resolve_gscdb_info_root(data_root, args.gscdb_root) folder_names = [p.strip() for p in args.gscdb_mol_folders.split(",") if p.strip()] gscdb_mol_folders = [data_root / p for p in folder_names if (data_root / p).is_dir()] if not gscdb_mol_folders: raise FileNotFoundError(f"None of the GSCDB mol folders {folder_names} exist under {data_root}") out_dir = Path(args.out_dir) if args.out_dir else ( CODE_ROOT / "runs" / "mace_delta" / datetime.now().strftime("%Y%m%d_%H%M%S") ) ckpt_dir = out_dir / "checkpoints" ckpt_dir.mkdir(parents=True, exist_ok=True) print(f"[OUT] logs & checkpoints: {out_dir}", flush=True) utils.set_seed(args.seed) train_ds, val_ds, mol_dirs = build_datasets( split_json=split_json, data_root=data_root, gscdb_root=gscdb_root, assets_dir=assets_dir, gscdb_mol_folders=gscdb_mol_folders, main_group_only=args.main_group_only, ) model = MACEDeltaB3LYPSkala( r_max=args.r_max, device=device, dtype=dtype, foundation=args.foundation, readout_hidden=args.readout_hidden, readout_layers=args.readout_layers, last_layer_weight_std=args.last_layer_weight_std, ) if args.init_checkpoint: load_weights_filtered(model, args.init_checkpoint, device) print(f"[init] loaded weights from {args.init_checkpoint}", flush=True) total_steps = args.total_steps warmup_steps = min(args.warmup_steps, max(0, total_steps - 1)) batch_size = max(1, args.batch_size) model.train() optimizer, scheduler = make_adafactor_cosine( model, max_lr=args.lr, warmup_steps=warmup_steps, total_steps=total_steps, clip_threshold=args.clip_threshold, ) run_meta = { "objective": "delta_b3lyp_E_base_plus_nn_delta", "E_mol": "E_unxc + E_xc_b3lyp + d3bj_b3lyp - 0.2*hf_x + delta_nn", "batch_size": batch_size, "total_steps": total_steps, "lr": args.lr, "warmup_steps": warmup_steps, "clip_threshold": args.clip_threshold, "seed": args.seed, "split_json": str(split_json), "assets_dir": str(assets_dir), "data_root": str(data_root), "gscdb_root": str(gscdb_root), "gscdb_mol_folders": mol_dirs, "main_group_only": bool(args.main_group_only), "foundation": args.foundation, "readout_hidden": args.readout_hidden, "readout_layers": args.readout_layers, "last_layer_weight_std": args.last_layer_weight_std, "r_max": model.r_max, "init_checkpoint": args.init_checkpoint or None, "out_dir": str(out_dir), } with open(out_dir / "run_meta.json", "w") as f: json.dump(run_meta, f, indent=2) print("params:", sum(p.numel() for p in model.parameters()), flush=True) history: list[dict] = [] global_step = 0 epoch = 0 best_val = float("inf") pbar = tqdm(total=total_steps, desc="train steps") while global_step < total_steps: model.train() train_ds.shuffle(seed=args.seed + epoch) optimizer.zero_grad(set_to_none=True) in_batch = 0 loss_accum, mae_accum = [], [] for i in range(len(train_ds)): if global_step >= total_steps: break rxn = train_ds[i] mols: dict = {} row = rxn_molecules_table_delta(rxn, mols, model.z_table) if row is None: continue pred_h, ref_h = forward_reaction_batch_delta_b3lyp_skala( [row], mols, model, model.r_max, device, dtype ) pred_k = pred_h * HARTREE2KCAL ref_k = ref_h * HARTREE2KCAL b = torch.as_tensor(float(rxn["baseline_mae"]), dtype=pred_k.dtype, device=pred_k.device) lw = loss_weighted_mse(pred_k, ref_k, b) loss_accum.append(float(lw.detach().cpu())) (lw / batch_size).backward() mae_accum.append(torch.abs(pred_h - ref_h).item() * HARTREE2KCAL) in_batch += 1 if in_batch == batch_size: optimizer.step() scheduler.step() optimizer.zero_grad(set_to_none=True) in_batch = 0 global_step += 1 pbar.update(1) if global_step >= total_steps: break if in_batch > 0: optimizer.step() scheduler.step() optimizer.zero_grad(set_to_none=True) global_step += 1 pbar.update(1) val_mae, val_wmse = eval_epoch(val_ds, model, device, dtype) row_h = { "epoch": epoch, "global_step": global_step, "train_loss_weighted_mse": float(np.mean(loss_accum)) if loss_accum else float("nan"), "train_mae_kcal": float(np.mean(mae_accum)) if mae_accum else float("nan"), "val_mae_kcal": val_mae, "val_loss_weighted_mse": val_wmse, "lr": float(optimizer.param_groups[0]["lr"]), } history.append(row_h) print(row_h, flush=True) with open(out_dir / "history.json", "w") as f: json.dump(history, f, indent=2) if np.isfinite(val_wmse) and val_wmse < best_val: best_val = val_wmse torch.save(model.state_dict(), ckpt_dir / "best.pt") epoch += 1 if args.checkpoint_every_epochs > 0 and epoch % args.checkpoint_every_epochs == 0: torch.save(model.state_dict(), ckpt_dir / f"epoch_{epoch - 1:04d}_step_{global_step}.pt") pbar.close() torch.save(model.state_dict(), ckpt_dir / "final.pt") if getattr(args, "save_full_checkpoint", False): torch.save( { "model": model.state_dict(), "optimizer": optimizer.state_dict(), "scheduler": scheduler.state_dict(), "global_step": global_step, "epoch": epoch, "seed": args.seed, }, ckpt_dir / "final_full.pt", ) print(f"[checkpoint] saved full optim/sched state → {ckpt_dir / 'final_full.pt'}", flush=True) print(f"[done] checkpoints: {ckpt_dir}", flush=True) return history def parse_args(argv=None) -> argparse.Namespace: ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("--lr", type=float, default=DEFAULT_LR) ap.add_argument("--total-steps", type=int, default=DEFAULT_TOTAL_STEPS) ap.add_argument("--warmup-steps", type=int, default=DEFAULT_WARMUP_STEPS) ap.add_argument("--batch-size", type=int, default=DEFAULT_BATCH_SIZE) ap.add_argument("--seed", type=int, default=42) ap.add_argument("--clip-threshold", type=float, default=DEFAULT_CLIP_THRESHOLD) ap.add_argument("--data-root", type=str, default=str(default_data_root())) ap.add_argument("--gscdb-root", type=str, default="") ap.add_argument("--gscdb-mol-folders", type=str, default="GSCDB,GSCDB_dmetals") ap.add_argument("--split-json", type=str, default=str(CONFIGS / "reaction_splits_skala_finetune.json")) ap.add_argument("--assets-dir", type=str, default=str(CONFIGS / "skala_finetune_assets")) ap.add_argument("--out-dir", type=str, default="") ap.add_argument("--checkpoint-every-epochs", type=int, default=1) ap.add_argument("--main-group-only", action=argparse.BooleanOptionalAction, default=False, help="Drop TM GSCDB prefixes from train/val (Table 2 uses full 2428/300).") ap.add_argument("--foundation", type=str, default="small") ap.add_argument("--readout-hidden", type=int, default=256) ap.add_argument("--readout-layers", type=int, default=3) ap.add_argument("--last-layer-weight-std", type=float, default=1e-6) ap.add_argument("--r-max", type=float, default=None) ap.add_argument("--init-checkpoint", type=str, default="") ap.add_argument("--save-full-checkpoint", action="store_true", help="Also write final_full.pt with model+optimizer+scheduler state.") return ap.parse_args(argv) def main(argv=None): train(parse_args(argv)) if __name__ == "__main__": main()