{ "cells": [ { "cell_type": "markdown", "id": "590517c3", "metadata": {}, "source": [ "# Training & testing CACE on Argon MD data: `xnn` vs the original CACE, step by step\n", "\n", "This notebook runs a **complete end-to-end interatomic-potential pipeline on a\n", "realistic Argon dataset, twice**, once with the `xnn` CACE\n", "(`xnn.gnn.models.cace`) and once with the **original**\n", "[`cace`](https://github.com/BingqingCheng/cace) package, and **compares the two\n", "at every stage**: data → graphs, model build, *same-function* weight transplant,\n", "training (same data / loss / optimiser / schedule / split), and held-out test\n", "metrics. It follows exactly the pattern of the MACE / NequIP / Allegro companions\n", "(`examples/gnn/{mace,nequip,allegro}/02_*`).\n", "\n", "> Notebook `../../fidelity_checks/cace_verification.ipynb` proves the two\n", "> implementations are the same function block-by-block to machine precision;\n", "> here we confirm it on the *actual Argon data* and compare full pipelines." ] }, { "cell_type": "markdown", "id": "69ba39d9", "metadata": {}, "source": [ "## 0. Setup: `float32` on the GPU for training speed" ] }, { "cell_type": "code", "execution_count": 1, "id": "06f5709d", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:56:27.487533Z", "iopub.status.busy": "2026-07-20T04:56:27.487264Z", "iopub.status.idle": "2026-07-20T04:56:31.471181Z", "shell.execute_reply": "2026-07-20T04:56:31.470529Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xnn: 0.1.0 | cace (original): 0.1.0\n", "device: cuda | NVIDIA A100 80GB PCIe\n" ] } ], "source": [ "# silence the expected warnings\n", "import logging, warnings\n", "logging.disable(logging.WARNING)\n", "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", "warnings.filterwarnings(\"ignore\", category=FutureWarning,\n", " message=\"You are using `torch.load` with `weights_only=False`\")\n", "\n", "import time\n", "import numpy as np\n", "import torch\n", "import matplotlib.pyplot as plt\n", "import ase.io\n", "\n", "torch.set_default_dtype(torch.float32)\n", "torch.manual_seed(0)\n", "DEVICE = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "DATA = \"../../../datasets/argon_md\" # shared across the examples\n", "import xnn, cace\n", "print(\"xnn:\", xnn.__version__, \"| cace (original): 0.1.0\")\n", "print(\"device:\", DEVICE, \"|\", torch.cuda.get_device_name(0) if DEVICE == \"cuda\" else \"\")" ] }, { "cell_type": "markdown", "id": "cefa39eb", "metadata": {}, "source": [ "## 1. Load the data and the reference energy $E_0$\n", "\n", "The isolated-atom frame fixes the per-species shift $E_0$; unwrapped MD\n", "coordinates are `wrap()`ed. The few fully vaporised (edgeless) frames are\n", "dropped from *both* pipelines. Note the two codes handle $E_0$ differently:\n", "xnn folds it into the model (`atom_ref`), the original `cace` subtracts it\n", "from the training labels (`AtomicData.from_atoms(..., atomic_energies=...)`):\n", "the same physics, applied at model level vs data level." ] }, { "cell_type": "code", "execution_count": 2, "id": "8c26205e", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:56:31.474375Z", "iopub.status.busy": "2026-07-20T04:56:31.474267Z", "iopub.status.idle": "2026-07-20T04:56:36.231404Z", "shell.execute_reply": "2026-07-20T04:56:36.230798Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train 193 / test 48 configs (dropped 7/2 edgeless) | E0: {18: 0.0}\n" ] } ], "source": [ "from ase import Atoms\n", "def _to_atoms(s): # rebuild an ASE Atoms for the upstream (CACE) side\n", " a = Atoms(numbers=s[\"atomic_numbers\"], positions=s[\"pos\"],\n", " cell=s[\"cell\"], pbc=[True, True, True])\n", " a.info[\"REF_energy\"] = float(s[\"energy\"])\n", " a.arrays[\"REF_forces\"] = np.asarray(s[\"forces\"])\n", " return a\n", "\n", "from xnn.common.data import AtomicDataset, load_dataset\n", "\n", "CUTOFF, SPECIES = 6.0, [18]\n", "E0 = {18: 0.0} # argon isolated-atom reference energy\n", "train_structs = load_dataset(\"argon_md\", split=\"train\")\n", "train_atoms = [_to_atoms(s) for s in train_structs]\n", "test_structs = load_dataset(\"argon_md\", split=\"test\")\n", "test_atoms = [_to_atoms(s) for s in test_structs]\n", "\n", "def with_edges(structs, atoms_list):\n", " ds = AtomicDataset(structs, CUTOFF)\n", " keep = [i for i in range(len(structs)) if ds[i].num_edges > 0]\n", " return ([structs[i] for i in keep], [atoms_list[i] for i in keep],\n", " len(structs) - len(keep))\n", "train_structs, train_atoms, n_tr = with_edges(train_structs, train_atoms)\n", "test_structs, test_atoms, n_te = with_edges(test_structs, test_atoms)\n", "print(f\"train {len(train_structs)} / test {len(test_structs)} configs \"\n", " f\"(dropped {n_tr}/{n_te} edgeless) | E0: {E0}\")" ] }, { "cell_type": "markdown", "id": "ae650392", "metadata": {}, "source": [ "## 2. Graphs in both pipelines, $\\lambda$, and one shared split\n", "\n", "CACE normalizes messages with the average number of neighbours\n", "(`avg_num_neighbors`), which we compute from the training graphs and pass to\n", "**both** models. The upstream pipeline builds its graphs with matscipy\n", "(`cace.data.AtomicData.from_atoms`), xnn with its own neighbour list; the\n", "edge sets must match exactly." ] }, { "cell_type": "code", "execution_count": 3, "id": "044da328", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:56:36.232971Z", "iopub.status.busy": "2026-07-20T04:56:36.232885Z", "iopub.status.idle": "2026-07-20T04:56:39.971054Z", "shell.execute_reply": "2026-07-20T04:56:39.970412Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "total edges xnn = 1372560 cace = 1372558 | per-frame max diff = 2\n", "avg neighbours lambda = 17.779 -> used by both models\n", "train 174 / val 19 configs (identical for both models)\n" ] } ], "source": [ "from cace.data import AtomicData as CaceAtomicData\n", "from cace.tools import torch_geometric as cace_tg\n", "\n", "DATA_KEY = {\"energy\": \"REF_energy\", \"forces\": \"REF_forces\"}\n", "\n", "xnn_train = AtomicDataset(train_structs, CUTOFF)\n", "xnn_test = AtomicDataset(test_structs, CUTOFF)\n", "xnn_edges = np.array([xnn_train[i].num_edges for i in range(len(xnn_train))])\n", "LAMBDA = float(xnn_edges.sum() /\n", " sum(xnn_train[i].num_nodes for i in range(len(xnn_train))))\n", "\n", "def to_upstream(atoms_list):\n", " return [CaceAtomicData.from_atoms(a, cutoff=CUTOFF, data_key=dict(DATA_KEY),\n", " atomic_energies=E0) for a in atoms_list]\n", "up_train = to_upstream(train_atoms)\n", "up_test = to_upstream(test_atoms)\n", "up_edges = np.array([d.edge_index.shape[1] for d in up_train])\n", "print(f\"total edges xnn = {int(xnn_edges.sum())} cace = {int(up_edges.sum())} \"\n", " f\"| per-frame max diff = {np.abs(xnn_edges - up_edges).max()}\")\n", "print(f\"avg neighbours lambda = {LAMBDA:.3f} -> used by both models\")\n", "\n", "g = torch.Generator().manual_seed(0)\n", "perm = torch.randperm(len(train_structs), generator=g).tolist()\n", "n_val = max(1, int(0.1 * len(train_structs)))\n", "val_idx, train_idx = perm[:n_val], perm[n_val:]\n", "print(f\"train {len(train_idx)} / val {len(val_idx)} configs (identical for both models)\")" ] }, { "cell_type": "markdown", "id": "3b8eabf0", "metadata": {}, "source": [ "## 3. Build both models with identical hyper-parameters\n", "\n", "A small-but-real CACE, close to the paper's water model: $N_{\\rm emb}=2$\n", "(single element), 6 trainable Bessel functions mixed into $n=8$ radial channels,\n", "$l_{\\max}=3$, $\\nu_{\\max}=3$, one message-passing layer with all three\n", "mechanisms, and the linear + [32, 16] MLP readout." ] }, { "cell_type": "code", "execution_count": 4, "id": "b0dbf7e7", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:56:39.972678Z", "iopub.status.busy": "2026-07-20T04:56:39.972602Z", "iopub.status.idle": "2026-07-20T04:56:41.784206Z", "shell.execute_reply": "2026-07-20T04:56:41.783508Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "parameters: xnn 14805 | original CACE 14605 (xnn adds the 200-entry atom_ref table: 200)\n" ] } ], "source": [ "from cace.modules import BesselRBF as UpBessel, PolynomialCutoff as UpPoly\n", "from cace.modules.atomwise import Atomwise\n", "from cace.modules.forces import Forces\n", "from cace.representations import Cace as UpCace\n", "from cace.models.atomistic import NeuralNetworkPotential\n", "\n", "from xnn.common.config import from_dict\n", "from xnn.common.models import build_model, ForceStressOutput\n", "\n", "NAB, NRBF, NRB, LMAX, NU, T = 2, 6, 8, 3, 3, 1\n", "TYPES = [\"M\", \"Ar\", \"Bchi\"]\n", "EW, FW, LR, WD, BS, EPOCHS = 1.0, 100.0, 0.01, 5e-7, 10, 80\n", "\n", "def make_upstream():\n", " rep = UpCace(zs=SPECIES, n_atom_basis=NAB, cutoff=CUTOFF,\n", " radial_basis=UpBessel(cutoff=CUTOFF, n_rbf=NRBF, trainable=True),\n", " cutoff_fn=UpPoly(cutoff=CUTOFF, p=6),\n", " max_l=LMAX, max_nu=NU, num_message_passing=T,\n", " type_message_passing=TYPES, n_radial_basis=NRB,\n", " avg_num_neighbors=LAMBDA, embed_receiver_nodes=True)\n", " atomwise = Atomwise(n_layers=3, n_hidden=[32, 16], output_key=\"CACE_energy\",\n", " add_linear_nn=True)\n", " forces = Forces(calc_forces=True, calc_stress=False,\n", " energy_key=\"CACE_energy\", forces_key=\"CACE_forces\")\n", " return NeuralNetworkPotential(representation=rep,\n", " output_modules=[atomwise, forces])\n", "\n", "# ---- xnn model (core Config; upstream Cace(...) constructor spellings also\n", "# ---- work via the key-translation registry in xnn.common.config.translate) ----\n", "core = from_dict({\n", " \"model\": {\"name\": \"cace\", \"cutoff\": CUTOFF, \"n_interactions\": T, \"n_rbf\": NRBF,\n", " \"species\": SPECIES, \"n_atom_basis\": NAB, \"n_radial_basis\": NRB,\n", " \"max_l\": LMAX, \"max_nu\": NU, \"message_types\": TYPES,\n", " \"embed_receiver_nodes\": True, \"avg_num_neighbors\": LAMBDA,\n", " \"atomic_energies\": [E0[18]]},\n", " \"data\": {\"batch_size\": BS},\n", " \"optim\": {\"lr\": LR, \"weight_decay\": WD, \"epochs\": EPOCHS, \"energy_weight\": EW,\n", " \"force_weight\": FW, \"scheduler\": \"plateau\"},\n", " \"device\": DEVICE, \"seed\": 0, \"output_dir\": \"runs/argon_xnn\",\n", "})\n", "torch.manual_seed(0)\n", "xnn_model = ForceStressOutput(build_model(core.model)).to(DEVICE)\n", "\n", "torch.manual_seed(0)\n", "cace_nnp = make_upstream().to(DEVICE)\n", "# one batch through the upstream model lazy-initializes Bchi's H net + the readout\n", "b0 = next(iter(cace_tg.dataloader.DataLoader(dataset=up_train[:2], batch_size=2))).to(DEVICE)\n", "_ = cace_nnp(b0.to_dict(), training=True)\n", "\n", "p_x = sum(p.numel() for p in xnn_model.parameters())\n", "p_u = sum(p.numel() for p in cace_nnp.parameters())\n", "print(f\"parameters: xnn {p_x} | original CACE {p_u} \"\n", " f\"(xnn adds the 200-entry atom_ref table: {p_x - p_u})\")" ] }, { "cell_type": "markdown", "id": "3dbdc91d", "metadata": {}, "source": [ "## 3b. Are they the *same function*? Weight transplant on the Argon data\n", "\n", "Copy **every** weight from the original CACE into the `xnn` model and compare\n", "on real **periodic** Argon test configurations (float32 round-off; ~$10^{-15}$\n", "relative in float64, see notebook 01). The xnn energies include $E_0$ via\n", "`atom_ref`, so we add $N_{\\rm atoms} E_0$ to the upstream predictions." ] }, { "cell_type": "code", "execution_count": 5, "id": "cf81e4c7", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:56:41.785721Z", "iopub.status.busy": "2026-07-20T04:56:41.785641Z", "iopub.status.idle": "2026-07-20T04:56:45.486400Z", "shell.execute_reply": "2026-07-20T04:56:45.483158Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "transplanted models on Argon test configs (float32):\n", " max |E_xnn - E_cace| = 4.96e-05 eV | max |F_xnn - F_cace| = 9.98e-07 eV/A -> identical to round-off\n" ] } ], "source": [ "def transplant(x, rep, readout):\n", " with torch.no_grad():\n", " x.embed_sender.copy_(rep.node_embedding_sender.embedding_weights)\n", " x.embed_receiver.copy_(rep.node_embedding_receiver.embedding_weights)\n", " x.rbf.freqs.copy_(rep.radial_basis.bessel_weights * float(rep.cutoff))\n", " x.radial_transform.weight.copy_(torch.stack(list(rep.radial_transform.weights)))\n", " for t, (nm, ar, bchi) in enumerate(rep.message_passing_list):\n", " xi = x.interactions[t]\n", " if nm is not None:\n", " xi.memory.memory_coef.copy_(torch.stack(list(nm.memory_coef)))\n", " if ar is not None:\n", " xi.message_ar.prefactor.copy_(torch.stack(list(ar.prefactor)))\n", " xi.message_ar.inv_r0.copy_(torch.stack(list(ar.invr0)))\n", " if bchi is not None:\n", " xi.message_bchi.h.weight.copy_(bchi.hnet[0].linear.weight)\n", " xi.message_bchi.h.bias.copy_(bchi.hnet[0].linear.bias)\n", " for j, dense in enumerate(readout.outnet):\n", " x.readout_mlp[2 * j].weight.copy_(dense.linear.weight)\n", " x.readout_mlp[2 * j].bias.copy_(dense.linear.bias)\n", " x.readout_linear.weight.copy_(readout.linear_nn.linear.weight)\n", " x.readout_linear.bias.copy_(readout.linear_nn.linear.bias)\n", "\n", "transplant(xnn_model.model, cace_nnp.representation, cace_nnp.output_modules[0])\n", "\n", "dE, dF = [], []\n", "for k in range(8):\n", " ox = xnn_model(xnn_test[k].to(DEVICE))\n", " b = next(iter(cace_tg.dataloader.DataLoader(dataset=[up_test[k]], batch_size=1))).to(DEVICE)\n", " ou = cace_nnp(b.to_dict(), training=True)\n", " n_at = len(test_structs[k][\"atomic_numbers\"])\n", " dE.append(abs(float(ox[\"energy\"]) - (float(ou[\"CACE_energy\"]) + n_at * E0[18])))\n", " dF.append(np.abs(ox[\"forces\"].detach().cpu().numpy()\n", " - ou[\"CACE_forces\"].detach().cpu().numpy()).max())\n", "print(\"transplanted models on Argon test configs (float32):\")\n", "print(f\" max |E_xnn - E_cace| = {max(dE):.2e} eV | \"\n", " f\"max |F_xnn - F_cace| = {max(dF):.2e} eV/A -> identical to round-off\")\n", "\n", "# re-initialize both freshly for the fair training comparison below\n", "torch.manual_seed(0)\n", "xnn_model = ForceStressOutput(build_model(core.model)).to(DEVICE)\n", "torch.manual_seed(0)\n", "cace_nnp = make_upstream().to(DEVICE)\n", "_ = cace_nnp(b0.to_dict(), training=True)" ] }, { "cell_type": "markdown", "id": "5eebee86", "metadata": {}, "source": [ "## 4a. Train the `xnn` model (`xnn.train.Trainer`)" ] }, { "cell_type": "code", "execution_count": 6, "id": "ae1e3a6b", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:56:45.489023Z", "iopub.status.busy": "2026-07-20T04:56:45.488916Z", "iopub.status.idle": "2026-07-20T04:59:33.317428Z", "shell.execute_reply": "2026-07-20T04:59:33.316406Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xnn: 80 epochs in 167.3 s | final train 4.7296e-04 val 2.9571e-04\n" ] } ], "source": [ "from torch.utils.data import Subset\n", "from xnn.common.train import Trainer\n", "\n", "trainer = Trainer(core, Subset(xnn_train, train_idx), Subset(xnn_train, val_idx))\n", "trainer.model = xnn_model.to(trainer.device)\n", "trainer.opt = torch.optim.Adam(trainer.model.parameters(), lr=LR, weight_decay=WD)\n", "trainer.sched = torch.optim.lr_scheduler.ReduceLROnPlateau(trainer.opt, patience=10)\n", "\n", "hist_x = {\"train\": [], \"val\": []}\n", "def _rec(epoch, tr, va):\n", " hist_x[\"train\"].append(tr.get(\"loss\")); hist_x[\"val\"].append(va.get(\"loss\"))\n", "trainer._log = _rec\n", "\n", "t0 = time.time(); trainer.fit(); t_x = time.time() - t0\n", "print(f\"xnn: {EPOCHS} epochs in {t_x:.1f} s | \"\n", " f\"final train {hist_x['train'][-1]:.4e} val {hist_x['val'][-1]:.4e}\")" ] }, { "cell_type": "markdown", "id": "10cc5a4a", "metadata": {}, "source": [ "## 4b. Train the **original CACE**: same data, loss, optimiser, schedule\n", "\n", "(The packaged route is `cace.tasks.TrainingTask`; a transparent hand-rolled\n", "loop guarantees identical loss/optimiser/schedule to the xnn `Trainer`. The\n", "upstream labels are $E_0$-subtracted, the xnn model carries $E_0$ in\n", "`atom_ref`; the losses see the same residuals.)" ] }, { "cell_type": "code", "execution_count": 7, "id": "15f6a5e3", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:59:33.319363Z", "iopub.status.busy": "2026-07-20T04:59:33.319257Z", "iopub.status.idle": "2026-07-20T05:40:49.403624Z", "shell.execute_reply": "2026-07-20T05:40:49.402782Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "cace: 80 epochs in 2476.1 s | final train 7.1243e-04 val 5.0509e-04\n" ] } ], "source": [ "tr_loader = cace_tg.dataloader.DataLoader(dataset=[up_train[i] for i in train_idx],\n", " batch_size=BS, shuffle=True)\n", "va_loader = cace_tg.dataloader.DataLoader(dataset=[up_train[i] for i in val_idx],\n", " batch_size=BS, shuffle=False)\n", "opt = torch.optim.Adam(cace_nnp.parameters(), lr=LR, weight_decay=WD)\n", "sched = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, patience=10)\n", "\n", "def up_loss(pred, b):\n", " n = torch.bincount(b.batch).to(pred[\"CACE_energy\"].dtype)\n", " e = (((pred[\"CACE_energy\"] - b.energy) / n) ** 2).mean()\n", " return EW * e + FW * ((pred[\"CACE_forces\"] - b.forces) ** 2).mean()\n", "\n", "hist_u = {\"train\": [], \"val\": []}\n", "t0 = time.time()\n", "for epoch in range(EPOCHS):\n", " cace_nnp.train(); tl = 0.0\n", " for b in tr_loader:\n", " b = b.to(DEVICE)\n", " loss = up_loss(cace_nnp(b.to_dict(), training=True), b)\n", " opt.zero_grad(); loss.backward(); opt.step()\n", " tl += float(loss.detach())\n", " cace_nnp.eval(); vl = 0.0\n", " for b in va_loader:\n", " b = b.to(DEVICE)\n", " vl += float(up_loss(cace_nnp(b.to_dict(), training=False), b).detach())\n", " tl /= len(tr_loader); vl /= len(va_loader)\n", " sched.step(vl)\n", " hist_u[\"train\"].append(tl); hist_u[\"val\"].append(vl)\n", "t_u = time.time() - t0\n", "print(f\"cace: {EPOCHS} epochs in {t_u:.1f} s | \"\n", " f\"final train {hist_u['train'][-1]:.4e} val {hist_u['val'][-1]:.4e}\")" ] }, { "cell_type": "markdown", "id": "c981803a", "metadata": {}, "source": [ "### Training-loss curves: both models" ] }, { "cell_type": "code", "execution_count": 8, "id": "cbc03cd0", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T05:40:49.405359Z", "iopub.status.busy": "2026-07-20T05:40:49.405265Z", "iopub.status.idle": "2026-07-20T05:40:50.120679Z", "shell.execute_reply": "2026-07-20T05:40:50.119788Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "training time: xnn 167s cace 2476s\n" ] } ], "source": [ "fig, ax = plt.subplots(1, 2, figsize=(11, 3.6))\n", "ep = range(1, EPOCHS + 1)\n", "for a, key, ttl in [(ax[0], \"train\", \"training loss\"), (ax[1], \"val\", \"validation loss\")]:\n", " a.plot(ep, hist_x[key], label=\"xnn\"); a.plot(ep, hist_u[key], label=\"cace\")\n", " a.set_yscale(\"log\"); a.set_xlabel(\"epoch\"); a.set_ylabel(key + \" loss\")\n", " a.legend(); a.set_title(ttl)\n", "plt.tight_layout(); plt.savefig(\"argon_loss_curves.png\", dpi=120); plt.show()\n", "print(f\"training time: xnn {t_x:.0f}s cace {t_u:.0f}s\")" ] }, { "cell_type": "markdown", "id": "3a80bdf2", "metadata": {}, "source": [ "## 5. Evaluate both trained models on the held-out test set" ] }, { "cell_type": "code", "execution_count": 9, "id": "6c6a483f", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T05:40:50.122147Z", "iopub.status.busy": "2026-07-20T05:40:50.122075Z", "iopub.status.idle": "2026-07-20T05:41:03.424964Z", "shell.execute_reply": "2026-07-20T05:41:03.423927Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "metric xnn original CACE\n", "--------------------------------------------------\n", "energy RMSE [meV/atom] 13.45 13.26\n", "energy MAE [meV/atom] 10.52 9.28\n", "force RMSE [meV/A] 2.57 3.09\n", "force MAE [meV/A] 1.43 1.97\n" ] } ], "source": [ "def eval_xnn(model):\n", " model.eval(); Ep, Er, na, Fp, Fr = [], [], [], [], []\n", " for s, i in zip(test_structs, range(len(xnn_test))):\n", " out = model(xnn_test[i].to(DEVICE))\n", " Ep.append(float(out[\"energy\"].detach())); Er.append(s[\"energy\"]); na.append(len(s[\"atomic_numbers\"]))\n", " Fp.append(out[\"forces\"].detach().cpu().numpy()); Fr.append(s[\"forces\"])\n", " return map(np.array, (Ep, Er, na)), np.concatenate(Fp), np.concatenate(Fr)\n", "\n", "def eval_upstream(model):\n", " model.eval(); Ep, Er, na, Fp, Fr = [], [], [], [], []\n", " for s, d in zip(test_structs, up_test):\n", " b = next(iter(cace_tg.dataloader.DataLoader(dataset=[d], batch_size=1))).to(DEVICE)\n", " out = model(b.to_dict(), training=False)\n", " n_at = len(s[\"atomic_numbers\"])\n", " Ep.append(float(out[\"CACE_energy\"].detach()) + n_at * E0[18])\n", " Er.append(s[\"energy\"]); na.append(n_at)\n", " Fp.append(out[\"CACE_forces\"].detach().cpu().numpy()); Fr.append(s[\"forces\"])\n", " return map(np.array, (Ep, Er, na)), np.concatenate(Fp), np.concatenate(Fr)\n", "\n", "def metrics(EpErNa, Fp, Fr):\n", " Ep, Er, na = EpErNa\n", " e = (Ep - Er) / na * 1000.0; f = (Fp - Fr) * 1000.0\n", " return dict(e_rmse=np.sqrt((e**2).mean()), e_mae=np.abs(e).mean(),\n", " f_rmse=np.sqrt((f**2).mean()), f_mae=np.abs(f).mean(),\n", " Ep=Ep/na, Er=Er/na, Fp=Fp, Fr=Fr)\n", "\n", "res_x = metrics(*eval_xnn(trainer.model))\n", "res_u = metrics(*eval_upstream(cace_nnp))\n", "print(f\"{'metric':<24}{'xnn':>10}{'original CACE':>16}\")\n", "print(\"-\" * 50)\n", "for k, lbl in [(\"e_rmse\", \"energy RMSE [meV/atom]\"), (\"e_mae\", \"energy MAE [meV/atom]\"),\n", " (\"f_rmse\", \"force RMSE [meV/A]\"), (\"f_mae\", \"force MAE [meV/A]\")]:\n", " print(f\"{lbl:<24}{res_x[k]:>10.2f}{res_u[k]:>16.2f}\")" ] }, { "cell_type": "markdown", "id": "c503c579", "metadata": {}, "source": [ "### Side-by-side parity plots" ] }, { "cell_type": "code", "execution_count": 10, "id": "eb2639cb", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T05:41:03.426982Z", "iopub.status.busy": "2026-07-20T05:41:03.426846Z", "iopub.status.idle": "2026-07-20T05:41:04.584011Z", "shell.execute_reply": "2026-07-20T05:41:04.583320Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plt.subplots(2, 2, figsize=(9.5, 9))\n", "rng = np.random.default_rng(0)\n", "idx = rng.choice(res_x[\"Fr\"].size, size=min(4000, res_x[\"Fr\"].size), replace=False)\n", "for col, (res, name) in enumerate([(res_x, \"xnn\"), (res_u, \"original CACE\")]):\n", " a0 = ax[0, col]\n", " lim = [min(res[\"Er\"].min(), res[\"Ep\"].min()), max(res[\"Er\"].max(), res[\"Ep\"].max())]\n", " a0.plot(lim, lim, \"k--\", lw=1); a0.scatter(res[\"Er\"], res[\"Ep\"], s=26, alpha=0.7)\n", " a0.set_xlabel(\"ref E/atom [eV]\"); a0.set_ylabel(\"pred E/atom [eV]\")\n", " a0.set_title(f\"{name}: energy (RMSE {res['e_rmse']:.1f} meV/atom)\")\n", " a1 = ax[1, col]\n", " fr, fp = res[\"Fr\"].ravel()[idx], res[\"Fp\"].ravel()[idx]\n", " lim = [min(fr.min(), fp.min()), max(fr.max(), fp.max())]\n", " a1.plot(lim, lim, \"k--\", lw=1); a1.scatter(fr, fp, s=6, alpha=0.3)\n", " a1.set_xlabel(\"ref force [eV/A]\"); a1.set_ylabel(\"pred force [eV/A]\")\n", " a1.set_title(f\"{name}: forces (RMSE {res['f_rmse']:.1f} meV/A)\")\n", "plt.tight_layout(); plt.savefig(\"argon_parity_xnn_vs_cace.png\", dpi=120); plt.show()" ] }, { "cell_type": "markdown", "id": "fddee415", "metadata": {}, "source": [ "## 6. ASE calculators (deployment): both codes\n", "\n", "(The upstream `CACECalculator` needs one small compatibility shim: it stores\n", "the energy as a shape-`(1,)` array, and `float()` of a size-1 array was\n", "removed in numpy ≥ 2; the subclass below finishes the conversion.)" ] }, { "cell_type": "code", "execution_count": 11, "id": "60622e35", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T05:41:04.585446Z", "iopub.status.busy": "2026-07-20T05:41:04.585369Z", "iopub.status.idle": "2026-07-20T05:41:05.000168Z", "shell.execute_reply": "2026-07-20T05:41:04.999433Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ASE single point: xnn E = -26.9191 eV | original CACE E = -27.9981 eV | reference E = -31.0395 eV\n" ] } ], "source": [ "from ase import Atoms\n", "from ase.calculators.calculator import all_changes\n", "from xnn.common.deploy import XNNCalculator\n", "from cace.calculators import CACECalculator\n", "\n", "class PatchedCACECalculator(CACECalculator):\n", " '''Upstream stores energy as a shape-(1,) array; float() of it raises on numpy>=2.'''\n", " def calculate(self, atoms=None, properties=None, system_changes=all_changes):\n", " try:\n", " super().calculate(atoms, properties, system_changes)\n", " except TypeError: # forces/stress are already in results at this point\n", " self.results[\"energy\"] = float(np.asarray(self.results[\"energy\"]).reshape(-1)[0])\n", " self.results[\"forces\"] = np.asarray(self.results[\"forces\"], dtype=np.float64)\n", " return self.results\n", "\n", "s = test_structs[0]\n", "atoms = Atoms(numbers=s[\"atomic_numbers\"], positions=s[\"pos\"], cell=s[\"cell\"], pbc=True)\n", "atoms.calc = XNNCalculator(trainer.model.to(\"cpu\"), cutoff=CUTOFF)\n", "e_x = atoms.get_potential_energy()\n", "\n", "atoms_u = atoms.copy()\n", "atoms_u.calc = PatchedCACECalculator(cace_nnp.to(\"cpu\"), device=\"cpu\",\n", " energy_key=\"CACE_energy\", forces_key=\"CACE_forces\",\n", " atomic_energies=E0)\n", "e_u = atoms_u.get_potential_energy()\n", "print(f\"ASE single point: xnn E = {e_x:.4f} eV | original CACE E = {e_u:.4f} eV | \"\n", " f\"reference E = {s['energy']:.4f} eV\")" ] }, { "cell_type": "markdown", "id": "a89387cd", "metadata": {}, "source": [ "## Summary: every stage compared\n", "\n", "| stage | result |\n", "|---|---|\n", "| **Data → graphs** | identical edge sets from the xnn neighbour list and upstream matscipy |\n", "| **Model build** | identical architecture; parameter counts match except xnn's 200-entry `atom_ref` table |\n", "| **Same function?** | weight transplant → **identical E and F on periodic Argon** (float32 round-off) |\n", "| **Training** | same data / loss / optimiser / schedule → comparable loss curves |\n", "| **Test accuracy** | energy and force RMSE/MAE agree between the two implementations |\n", "\n", "The `xnn` CACE is a faithful re-implementation of the original CACE with **zero\n", "extra dependencies** (not even e3nn); residual metric differences come only from\n", "independent initialisation and shuffling. The companion notebook\n", "`cace_argon_density_md.ipynb` runs NPT MD with both codes." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.12" } }, "nbformat": 4, "nbformat_minor": 5 }