models/matris/eval_matris.py

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()