from __future__ import annotations import argparse import collections from pathlib import Path import torch from torch import nn from torch.utils.data import DataLoader from tqdm import tqdm from matris.model.model import MatRIS from matris.model.reference_energy import AtomRef from matris_dataset import ( MatRISDataset, matris_collate_fn, move_matris_batch_to_device, ) REPO_ROOT = Path(__file__).resolve().parents[2] TEST_PATH = REPO_ROOT / "datasets/xyz/testdata.xyz" SAVE_DIR = REPO_ROOT / "models/matris/checkpoints_matris" E0S_DEFAULT = { 1: 2.467478445, # H 6: 8.0273263225, # C 8: 3.334308855, # O 22: 4.879036065, # Ti } def build_random_init_model( device: str, is_conservative: bool, use_reference_energy: bool, model_name: str | None = None, ) -> MatRIS: print("Building RANDOM INIT model") print(f"Requested model_name: {model_name}") if model_name is None or model_name == "none" or model_name == "": print("Random scratch MatRIS architecture") model = MatRIS(is_conservation=is_conservative) else: print(f"Random foundation architecture: {model_name}") model = MatRIS.load( model_name, device="cpu", cache_dir="foundation_models", ) model.force_stress_head.is_conservation = is_conservative if use_reference_energy: model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT) else: model.reference_energy = None model = model.to(device) model.eval() return model def build_reference_energy_module(model: MatRIS, e0_dict: dict[int, float]) -> AtomRef: atom_ref = AtomRef(reference_energy="mptrj", is_intensive=model.is_intensive) weight = torch.zeros(94, dtype=torch.float32) for Z, e0 in e0_dict.items(): weight[Z - 1] = e0 state_dict = collections.OrderedDict() state_dict["weight"] = weight.view(1, 94) atom_ref.fc.load_state_dict(state_dict) atom_ref.fitted = True for p in atom_ref.parameters(): p.requires_grad = False return atom_ref class MatRISEvalLoss(nn.Module): def __init__(self): super().__init__() self.l1_sum = nn.L1Loss(reduction="sum") self.l2_sum = nn.MSELoss(reduction="sum") def forward(self, pred_forces, ref_forces, pred_energy, ref_energy): loss_forces_l1 = self.l1_sum(pred_forces, ref_forces) loss_energy_l1 = self.l1_sum(pred_energy, ref_energy) loss_forces_l2 = self.l2_sum(pred_forces, ref_forces) loss_energy_l2 = self.l2_sum(pred_energy, ref_energy) return loss_forces_l1, loss_energy_l1, loss_forces_l2, loss_energy_l2 def load_matris_from_checkpoint( checkpoint_path: str | Path, device: str, is_conservative: bool, use_reference_energy: bool, model_name: str | None = None, ) -> MatRIS: checkpoint = torch.load(checkpoint_path, map_location="cpu", weights_only=False) print(f"Requested model_name: {model_name}") if model_name is None or model_name == "none" or model_name == "": print("Loading scratch MatRIS architecture") model = MatRIS(is_conservation=is_conservative) else: print(f"Loading foundation model architecture: {model_name}") model = MatRIS.load( model_name, device="cpu", cache_dir="foundation_models", ) model.force_stress_head.is_conservation = is_conservative if use_reference_energy: model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT) else: model.reference_energy = None model.load_state_dict(checkpoint["model_state_dict"], strict=True) model = model.to(device) model.eval() return model def evaluate(model, loader, loss_fn, use_grad, device, desc="Eval"): model.eval() sum_abs_dF = torch.tensor(0.0, device=device) sum_abs_dE = torch.tensor(0.0, device=device) sum_sq_dF = torch.tensor(0.0, device=device) sum_sq_dE = torch.tensor(0.0, device=device) sum_abs_dE_per_atom = torch.tensor(0.0, device=device) sum_sq_dE_per_atom = torch.tensor(0.0, device=device) total_force_components = torch.tensor(0.0, device=device) total_systems = torch.tensor(0.0, device=device) total_atoms = torch.tensor(0.0, device=device) # Important: no torch.no_grad(), because conservative forces need autograd. for batch in tqdm(loader, desc=desc, dynamic_ncols=True): # There's one sample in testset where this happens if batch is None: continue batch = move_matris_batch_to_device(batch, device=device) with torch.set_grad_enabled(use_grad): out = model(batch["graphs"], task="ef", is_training=False) n_atoms_per_graph = out["atoms_per_graph"].float() natoms_batch = n_atoms_per_graph.sum() n_systems = n_atoms_per_graph.numel() pred_energy = out["e"] if model.is_intensive: pred_energy = pred_energy * n_atoms_per_graph ref_energy = batch["energy"] pred_forces = torch.cat(out["f"], dim=0) ref_forces = torch.cat(batch["forces"], dim=0) loss_forces_l1, loss_energy_l1, loss_forces_l2, loss_energy_l2 = loss_fn( pred_forces=pred_forces, ref_forces=ref_forces, pred_energy=pred_energy, ref_energy=ref_energy, ) dE = pred_energy.view(-1) - ref_energy.view(-1) abs_dE = dE.abs() total_atoms += natoms_batch.detach() total_force_components += (3.0 * natoms_batch).detach() total_systems += torch.tensor(float(n_systems), device=device) sum_abs_dF += loss_forces_l1.detach() sum_abs_dE += loss_energy_l1.detach() sum_sq_dF += loss_forces_l2.detach() sum_sq_dE += loss_energy_l2.detach() sum_abs_dE_per_atom += (abs_dE / n_atoms_per_graph).sum().detach() sum_sq_dE_per_atom += ((dE / n_atoms_per_graph) ** 2).sum().detach() mae_F = (sum_abs_dF / total_force_components).item() mae_E_sys = (sum_abs_dE / total_systems).item() mae_E_atom_weighted = (sum_abs_dE / total_atoms).item() mae_E_atom_mace = (sum_abs_dE_per_atom / total_systems).item() rmse_F = torch.sqrt(sum_sq_dF / total_force_components).item() rmse_E_sys = torch.sqrt(sum_sq_dE / total_systems).item() rmse_E_atom_weighted = torch.sqrt(sum_sq_dE / total_atoms).item() rmse_E_atom_mace = torch.sqrt(sum_sq_dE_per_atom / total_systems).item() print() print("========== MatRIS Evaluation ==========") print(f"MAE(F components) [eV/A]: {mae_F:.6f}") print(f"MAE(E per system) [eV]: {mae_E_sys:.6f}") print(f"MAE(E per atom, weighted) [eV]: {mae_E_atom_weighted:.6f}") print(f"MAE(E per atom, MACE) [eV]: {mae_E_atom_mace:.6f}") print(f"MAE(E per atom, MACE) [meV]: {1000.0 * mae_E_atom_mace:.3f}") print() print(f"RMSE(F components) [eV/A]: {rmse_F:.6f}") print(f"RMSE(E per system) [eV]: {rmse_E_sys:.6f}") print(f"RMSE(E per atom, weighted) [eV]: {rmse_E_atom_weighted:.6f}") print(f"RMSE(E per atom, MACE) [eV]: {rmse_E_atom_mace:.6f}") print(f"RMSE(E per atom, MACE) [meV]: {1000.0 * rmse_E_atom_mace:.3f}") print("=======================================") return { "mae_F": mae_F, "mae_E_sys": mae_E_sys, "mae_E_atom_weighted": mae_E_atom_weighted, "mae_E_atom_mace": mae_E_atom_mace, "rmse_F": rmse_F, "rmse_E_sys": rmse_E_sys, "rmse_E_atom_weighted": rmse_E_atom_weighted, "rmse_E_atom_mace": rmse_E_atom_mace, } def parse_args(): parser = argparse.ArgumentParser(description="Evaluate a MatRIS checkpoint.") parser.add_argument("--test_path", type=str, default=str(TEST_PATH)) parser.add_argument("--checkpoint", type=str, default=None) parser.add_argument( "--random_init", action="store_true", help="Evaluate a randomly initialized model instead of loading checkpoint weights.", ) parser.add_argument("--batch_size", type=int, default=1) parser.add_argument("--num_workers", type=int, default=0) parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu") parser.add_argument( "--is_conservative", action=argparse.BooleanOptionalAction, default=True, help="Use conservative forces.", ) parser.add_argument( "--use_reference_energy", action=argparse.BooleanOptionalAction, default=True, help="Use the same custom AtomRef reference energies as training.", ) parser.add_argument("--model_name", type=str, default="") return parser.parse_args() def main(): args = parse_args() print(f"Device: {args.device}") print(f"Checkpoint: {args.checkpoint}") print(f"Random init: {args.random_init}") print(f"Test path: {args.test_path}") print(f"Conservative forces: {args.is_conservative}") print(f"Use reference energy: {args.use_reference_energy}") if args.random_init: print("Evaluing random init model") model = build_random_init_model( device=args.device, is_conservative=args.is_conservative, use_reference_energy=args.use_reference_energy, model_name=args.model_name, ) else: if args.checkpoint is None: raise ValueError("--checkpoint is required unless --random_init is used.") model = load_matris_from_checkpoint( checkpoint_path=args.checkpoint, device=args.device, is_conservative=args.is_conservative, use_reference_energy=args.use_reference_energy, model_name=args.model_name, ) use_grad = model.force_stress_head.is_conservation print(f'use_grad is: {use_grad}') # NOTE Try a random init model. # print("Running random Matrsi model") # model = MatRIS(is_conservation=args.is_conservative).to(args.device) # model.reference_energy = build_reference_energy_module(model, E0S_DEFAULT).to(args.device) test_dataset = MatRISDataset(args.test_path, model=model) test_loader = DataLoader( test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, collate_fn=matris_collate_fn, ) loss_fn = MatRISEvalLoss() evaluate( model=model, loader=test_loader, loss_fn=loss_fn, use_grad = use_grad, device=args.device, desc="MatRIS Eval", ) if __name__ == "__main__": main()