#!/usr/bin/env python3 """MACE adaptive hybrid α.""" from __future__ import annotations import argparse import hashlib import json import sys 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 import data as mace_data # noqa: E402 from mace.tools import torch_geometric # noqa: E402 from mace_alpha.model import MACEAlphaHFReadout, load_weights_filtered # noqa: E402 # 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 _molecule_uid_alpha(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_x_B3LYP": float(mol["E_x_B3LYP"]), "E_c_B3LYP": float(mol["E_c_B3LYP"]), } 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_alpha(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", "E_x_B3LYP", "E_c_B3LYP"): if req not in mol: return None elems, _coords = _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_alpha(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_x_B3LYP": float(mol["E_x_B3LYP"]), "E_c_B3LYP": float(mol["E_c_B3LYP"]), } rec["mols"].append({"mol_id": uid, "coeff": float(mol.get("coeff", 1.0))}) return rec def _atomic_data_from_stored(mol: dict, z_table, r_max: float) -> mace_data.AtomicData: from ase import Atoms atoms = Atoms(symbols=mol["elements"], positions=np.asarray(mol["coords"], dtype=np.float32)) atoms.set_pbc([False, False, False]) atoms.set_cell(np.eye(3, dtype=np.float32) * 100.0) config = mace_data.config_from_atoms(atoms) return mace_data.AtomicData.from_config(config, z_table=z_table, cutoff=r_max) def forward_reaction_batch_alpha_hf( reactions: list, molecules: dict, model: MACEAlphaHFReadout, r_max: float, device: torch.device, dtype: torch.dtype, ): all_mol_ids, rxn_indices, coeffs, ref_h = [], [], [], [] for ir, rxn in enumerate(reactions): ref_h.append(torch.as_tensor(rxn["energy_kcal"] / HARTREE2KCAL, dtype=dtype, device=device)) for item in rxn["mols"]: all_mol_ids.append(item["mol_id"]) rxn_indices.append(ir) coeffs.append(float(item["coeff"])) n_rxn = len(reactions) if len(all_mol_ids) == 0: pred_h = torch.zeros(n_rxn, dtype=dtype, device=device) return pred_h, torch.stack(ref_h) if ref_h else torch.zeros(0, dtype=dtype, device=device) atomic_list = [_atomic_data_from_stored(molecules[mid], model.z_table, r_max) for mid in all_mol_ids] loader = torch_geometric.dataloader.DataLoader( dataset=atomic_list, batch_size=len(atomic_list), shuffle=False, drop_last=False ) batch = next(iter(loader)).to(device) batch.positions = batch.positions.to(dtype) batch.node_attrs = batch.node_attrs.to(dtype) batch.shifts = batch.shifts.to(dtype) batch.cell = batch.cell.to(dtype) alpha = model.forward_atomic_batch(batch) rxn_indices_t = torch.as_tensor(rxn_indices, dtype=torch.long, device=device) coeffs_t = torch.as_tensor(coeffs, dtype=dtype, device=device) E_mols = [] for mid, a in zip(all_mol_ids, alpha): m = molecules[mid] # Pickle E_x_B3LYP is the B3LYP-weighted DFT-X piece (×0.8); undo to get E_x^B3. Ex_B3 = 1.25 * torch.as_tensor(m["E_x_B3LYP"], dtype=dtype, device=device) Ec_B3 = torch.as_tensor(m["E_c_B3LYP"], dtype=dtype, device=device) D3 = torch.as_tensor(m["d3bj_b3lyp"], dtype=dtype, device=device) Ex_HF = -torch.as_tensor(m["hf_x"], dtype=dtype, device=device) # stored hf_x = -E_x^HF E_unxc = torch.as_tensor(m["E_unxc"], dtype=dtype, device=device) Exc = a * Ex_HF + (1.0 - a) * Ex_B3 + Ec_B3 + D3 E_mols.append(E_unxc + Exc) E_mols_t = torch.stack(E_mols) pred_h = torch.zeros(n_rxn, dtype=dtype, device=device) pred_h.index_add_(0, rxn_indices_t, coeffs_t * E_mols_t) return pred_h, torch.stack(ref_h) @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_alpha(rxn, mols, model.z_table) if row is None: continue pred_h, ref_h = forward_reaction_batch_alpha_hf([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_alpha" / 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 = MACEAlphaHFReadout( r_max=args.r_max, device=str(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 partial/full 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 = { "model": "mace_alpha_hf_readout_skala", "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) 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_alpha(rxn, mols, model.z_table) if row is None: continue pred_h, ref_h = forward_reaction_batch_alpha_hf([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("--batch-size", type=int, default=DEFAULT_BATCH_SIZE) 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("--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()