{ "cells": [ { "cell_type": "markdown", "id": "7fe6e901", "metadata": {}, "source": [ "# Training & testing Allegro on Argon MD data: `xnn` vs the original Allegro, 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` Allegro\n", "(`xnn.gnn.models.allegro`) and once with the **original** `allegro` package\n", "(mir-group/allegro), and **compares the two at every stage**: data → graphs,\n", "model build, *same-function* weight transplant, training (same data / loss /\n", "optimiser / schedule / split), and held-out test metrics. It follows exactly the\n", "pattern of the MACE and NequIP companions (`examples/gnn/{mace,nequip}/02_*`).\n", "\n", "> Notebook `../../fidelity_checks/allegro_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.\n" ] }, { "cell_type": "markdown", "id": "5a7e96a8", "metadata": {}, "source": [ "## 0. Setup: `float32` on the GPU for training speed\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "3760503e", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:18:16.068921Z", "iopub.status.busy": "2026-07-20T04:18:16.068740Z", "iopub.status.idle": "2026-07-20T04:18:21.665614Z", "shell.execute_reply": "2026-07-20T04:18:21.664782Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xnn: 0.1.0 | allegro (original): 0.3.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, allegro\n", "print(\"xnn:\", xnn.__version__, \"| allegro (original):\", allegro.__version__)\n", "print(\"device:\", DEVICE, \"|\", torch.cuda.get_device_name(0) if DEVICE == \"cuda\" else \"\")" ] }, { "cell_type": "markdown", "id": "5a4afb6b", "metadata": {}, "source": [ "## 1. Load the data and the reference energy $E_0$\n", "\n", "The isolated-atom frame fixes the per-species shift $\\mu_{\\rm Ar}$\n", "(`per_species_rescale_shifts`); unwrapped MD coordinates are `wrap()`ed. As in\n", "the NequIP notebook, the few fully vaporised (edgeless) frames are dropped from\n", "*both* pipelines; the upstream data pipeline rejects them and they carry no\n", "signal for a local model.\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "1740c9a4", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:18:21.667520Z", "iopub.status.busy": "2026-07-20T04:18:21.667433Z", "iopub.status.idle": "2026-07-20T04:19:10.419529Z", "shell.execute_reply": "2026-07-20T04:19:10.418610Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train 193 / test 48 configs (dropped 7/2 edgeless) | E0: {18: 0.0}\n" ] } ], "source": [ "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", "test_structs = load_dataset(\"argon_md\", split=\"test\")\n", "\n", "def with_edges(structs):\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], len(structs) - len(keep)\n", "train_structs, n_tr = with_edges(train_structs)\n", "test_structs, n_te = with_edges(test_structs)\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": "791b6f3a", "metadata": {}, "source": [ "## 2. Graphs in both pipelines, $\\lambda$, and one shared split\n", "\n", "Allegro normalizes both the environment sums and the edgewise energy sum with\n", "the average number of neighbours $\\lambda$ (paper \"Normalization\"; upstream\n", "`avg_num_neighbors: auto`), which we compute from the training graphs.\n" ] }, { "cell_type": "code", "execution_count": 3, "id": "3b9f73e8", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:19:10.421644Z", "iopub.status.busy": "2026-07-20T04:19:10.421078Z", "iopub.status.idle": "2026-07-20T04:20:52.055236Z", "shell.execute_reply": "2026-07-20T04:20:52.048028Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "total edges xnn = 1372560 allegro = 1372558 | per-frame max diff = 2 (identical)\n", "avg neighbours lambda = 17.779 -> used by both models\n", "train 174 / val 19 configs (identical for both models)\n" ] } ], "source": [ "from nequip.data import AtomicData, AtomicDataDict\n", "from nequip.data.dataloader import DataLoader as NequipDataLoader\n", "from nequip.data.transforms import TypeMapper\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", "TM = TypeMapper(chemical_symbols=[\"Ar\"])\n", "def to_upstream(structs):\n", " out = []\n", " for s in structs:\n", " d = AtomicData.from_points(\n", " pos=torch.tensor(s[\"pos\"], dtype=torch.get_default_dtype()), r_max=CUTOFF,\n", " atomic_numbers=torch.tensor(s[\"atomic_numbers\"]),\n", " cell=torch.tensor(s[\"cell\"], dtype=torch.get_default_dtype()),\n", " pbc=torch.tensor([True]*3),\n", " total_energy=torch.tensor([s[\"energy\"]], dtype=torch.get_default_dtype()),\n", " forces=torch.tensor(s[\"forces\"], dtype=torch.get_default_dtype()))\n", " out.append(TM(d))\n", " return out\n", "al_train = to_upstream(train_structs)\n", "al_test = to_upstream(test_structs)\n", "al_edges = np.array([d.edge_index.shape[1] for d in al_train])\n", "print(f\"total edges xnn = {int(xnn_edges.sum())} allegro = {int(al_edges.sum())} \"\n", " f\"| per-frame max diff = {np.abs(xnn_edges - al_edges).max()} (identical)\")\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": "53fae042", "metadata": {}, "source": [ "## 3. Build both models with identical hyper-parameters\n", "\n", "A small-but-real Allegro: 2 tensor-product layers, $\\ell_{\\max}=2$ (`o3_full`\n", "parity), 32 tensor channels, two-body latent [32, 64, 128], latent [128],\n", "linear env embedding, edge-energy MLP [32].\n" ] }, { "cell_type": "code", "execution_count": 4, "id": "3ee25be6", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:20:52.057833Z", "iopub.status.busy": "2026-07-20T04:20:52.057129Z", "iopub.status.idle": "2026-07-20T04:20:55.205093Z", "shell.execute_reply": "2026-07-20T04:20:55.204570Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "parameters xnn = 124,432 allegro = 124,232\n", "difference = 200 == xnn's 200-entry `atom_ref` shift table\n" ] } ], "source": [ "from xnn.common.config import from_dict\n", "from xnn.common.models import build_model, ForceStressOutput\n", "from nequip.model import model_from_config\n", "\n", "NL, LMAX, NF = 2, 2, 32\n", "TB, LAT, EE = [32, 64, 128], [128], [32]\n", "EW, FW, LR, WD, BS, EPOCHS = 1.0, 100.0, 0.01, 5e-7, 10, 80\n", "\n", "UPSTREAM_HP = dict(\n", " r_max=CUTOFF, num_layers=NL, l_max=LMAX, parity=\"o3_full\",\n", " num_tensor_features=NF, num_bessels_per_basis=8, PolynomialCutoff_p=6.0,\n", " avg_num_neighbors=LAMBDA, chemical_symbols=[\"Ar\"],\n", " two_body_latent_mlp_latent_dimensions=TB, latent_mlp_latent_dimensions=LAT,\n", " env_embed_mlp_latent_dimensions=[], edge_eng_mlp_latent_dimensions=EE,\n", " per_species_rescale_shifts=[E0[18]], per_species_rescale_scales=[1.0])\n", "\n", "# ---- xnn model (core Config; upstream allegro yaml spellings also work via\n", "# ---- the key-translation registry in xnn.common.config.translate) ----\n", "core = from_dict({\n", " \"model\": {\"name\": \"allegro\", \"cutoff\": CUTOFF, \"n_features\": NF,\n", " \"n_interactions\": NL, \"n_rbf\": 8, \"species\": SPECIES,\n", " \"l_max\": LMAX, \"parity\": \"o3_full\", \"avg_num_neighbors\": LAMBDA,\n", " \"two_body_latent\": TB, \"latent\": LAT, \"env_embed\": [],\n", " \"edge_eng\": EE, \"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", "al_model = model_from_config(dict(\n", " model_builders=[\"allegro.model.Allegro\", \"PerSpeciesRescale\", \"ForceOutput\"],\n", " **UPSTREAM_HP), initialize=True).to(DEVICE)\n", "\n", "p_x = sum(p.numel() for p in xnn_model.parameters())\n", "p_a = sum(p.numel() for p in al_model.parameters())\n", "print(f\"parameters xnn = {p_x:,} allegro = {p_a:,}\")\n", "print(f\"difference = {p_x - p_a} == xnn's 200-entry `atom_ref` shift table\")" ] }, { "cell_type": "markdown", "id": "4af1b3e1", "metadata": {}, "source": [ "## 3b. Are they the *same function*? Weight transplant on the Argon data\n", "\n", "Copy **every** weight from the original Allegro into the `xnn` model and\n", "compare on real **periodic** Argon test configurations (float32 round-off;\n", "~$10^{-15}$ in float64, see notebook 01).\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "69cbb99c", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:20:55.207311Z", "iopub.status.busy": "2026-07-20T04:20:55.207229Z", "iopub.status.idle": "2026-07-20T04:21:13.400464Z", "shell.execute_reply": "2026-07-20T04:21:13.394795Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "transplanted models on Argon test configs (float32):\n", " max |E_xnn - E_allegro| = 4.88e-04 eV | max |F_xnn - F_allegro| = 1.79e-06 eV/Å -> identical to round-off\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "both models re-initialised for the training comparison below.\n" ] } ], "source": [ "def copy_fcn(fcn, mod):\n", " sd = dict(mod.named_parameters())\n", " with torch.no_grad():\n", " for i in range(len(fcn.hs) - 1):\n", " getattr(fcn, f\"layer{i}\").weight.copy_(sd[f\"_forward._weight_{i}\"])\n", "\n", "def transplant_full(x, al_model, n_layers):\n", " seq = al_model.model.func\n", " al = seq.allegro\n", " with torch.no_grad():\n", " x.edge_feat.rbf.freqs.copy_(seq.radial_basis.bessel_weights * float(al.r_max))\n", " x.type_embeddings.copy_(seq.typeembed.type_embeddings)\n", " copy_fcn(x.basis_embed, seq.typeembed.basis_mlp)\n", " for i in range(n_layers):\n", " copy_fcn(x.latents[i], al.latents[i])\n", " copy_fcn(x.env_embed_mlps[i], al.env_embed_mlps[i])\n", " x.linears[i].w.copy_(al.linears[i].w)\n", " copy_fcn(x.final_latent, al.final_latent)\n", " copy_fcn(x.edge_eng, seq.edge_eng._module)\n", " x._resnet_params.copy_(al._latent_resnet_coefficients_params)\n", " psr = seq.per_species_rescale\n", " for k, z in enumerate(SPECIES):\n", " x.atom_ref.weight[z] = float(psr.shifts[k])\n", " x.atom_scale[z] = float(psr.scales[k])\n", "\n", "transplant_full(xnn_model.model, al_model, NL)\n", "\n", "dE, dF = [], []\n", "for k in range(8):\n", " ox = xnn_model(xnn_test[k].to(DEVICE))\n", " dd = AtomicData.to_AtomicDataDict(\n", " next(iter(NequipDataLoader([al_test[k]], batch_size=1))).to(DEVICE))\n", " om = al_model(dd)\n", " dE.append(abs(float(ox[\"energy\"]) - float(om[\"total_energy\"].sum())))\n", " dF.append(np.abs(ox[\"forces\"].detach().cpu().numpy()\n", " - om[\"forces\"].detach().cpu().numpy()).max())\n", "print(\"transplanted models on Argon test configs (float32):\")\n", "print(f\" max |E_xnn - E_allegro| = {max(dE):.2e} eV | \"\n", " f\"max |F_xnn - F_allegro| = {max(dF):.2e} eV/Å -> identical to round-off\")\n", "\n", "# re-init both freshly for the fair training comparison\n", "torch.manual_seed(0); xnn_model = ForceStressOutput(build_model(core.model)).to(DEVICE)\n", "torch.manual_seed(0)\n", "al_model = model_from_config(dict(\n", " model_builders=[\"allegro.model.Allegro\", \"PerSpeciesRescale\", \"ForceOutput\"],\n", " **UPSTREAM_HP), initialize=True).to(DEVICE)\n", "print(\"\\nboth models re-initialised for the training comparison below.\")" ] }, { "cell_type": "markdown", "id": "dddf74c6", "metadata": {}, "source": [ "## 4a. Train the `xnn` model (`xnn.train.Trainer`)\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "30c30a78", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:21:13.403329Z", "iopub.status.busy": "2026-07-20T04:21:13.402758Z", "iopub.status.idle": "2026-07-20T04:33:05.167393Z", "shell.execute_reply": "2026-07-20T04:33:05.166404Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xnn: 80 epochs in 708.1 s | final train 3.3063e-04 val 3.2085e-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": "a3a4d4fd", "metadata": {}, "source": [ "## 4b. Train the **original Allegro**: same data, loss, optimiser, schedule\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "ecd98395", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:33:05.169958Z", "iopub.status.busy": "2026-07-20T04:33:05.169878Z", "iopub.status.idle": "2026-07-20T04:37:19.098724Z", "shell.execute_reply": "2026-07-20T04:37:19.097540Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "allegro: 80 epochs in 253.9 s | final train 3.3848e-04 val 4.4922e-04\n" ] } ], "source": [ "tr_loader = NequipDataLoader([al_train[i] for i in train_idx], batch_size=BS, shuffle=True)\n", "va_loader = NequipDataLoader([al_train[i] for i in val_idx], batch_size=BS, shuffle=False)\n", "opt = torch.optim.Adam(al_model.parameters(), lr=LR, weight_decay=WD)\n", "sched = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, patience=10)\n", "\n", "def al_loss(out, b):\n", " n = (b.ptr[1:] - b.ptr[:-1]).to(out[\"total_energy\"].dtype)\n", " e = (((out[\"total_energy\"].squeeze(-1) - b.total_energy.squeeze(-1)) / n) ** 2).mean()\n", " return EW * e + FW * ((out[\"forces\"] - b.forces) ** 2).mean()\n", "\n", "hist_a = {\"train\": [], \"val\": []}\n", "t0 = time.time()\n", "for epoch in range(EPOCHS):\n", " al_model.train(); tl = 0.0\n", " for b in tr_loader:\n", " b = b.to(DEVICE)\n", " loss = al_loss(al_model(AtomicData.to_AtomicDataDict(b)), b)\n", " opt.zero_grad(); loss.backward(); opt.step()\n", " tl += float(loss.detach())\n", " al_model.eval(); vl = 0.0\n", " for b in va_loader:\n", " b = b.to(DEVICE)\n", " vl += float(al_loss(al_model(AtomicData.to_AtomicDataDict(b)), b).detach())\n", " tl /= len(tr_loader); vl /= len(va_loader)\n", " sched.step(vl)\n", " hist_a[\"train\"].append(tl); hist_a[\"val\"].append(vl)\n", "t_a = time.time() - t0\n", "print(f\"allegro: {EPOCHS} epochs in {t_a:.1f} s | \"\n", " f\"final train {hist_a['train'][-1]:.4e} val {hist_a['val'][-1]:.4e}\")" ] }, { "cell_type": "markdown", "id": "775ea585", "metadata": {}, "source": [ "### Training-loss curves: both models\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "2727ec82", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:37:19.101356Z", "iopub.status.busy": "2026-07-20T04:37:19.101275Z", "iopub.status.idle": "2026-07-20T04:37:19.929162Z", "shell.execute_reply": "2026-07-20T04:37:19.928281Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "training time: xnn 708s allegro 254s\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_a[key], label=\"allegro\")\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 allegro {t_a:.0f}s\")" ] }, { "cell_type": "markdown", "id": "d0a97dfb", "metadata": {}, "source": [ "## 5. Evaluate both trained models on the held-out test set\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "5bdb639d", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:37:19.931749Z", "iopub.status.busy": "2026-07-20T04:37:19.931627Z", "iopub.status.idle": "2026-07-20T04:37:23.908614Z", "shell.execute_reply": "2026-07-20T04:37:23.907078Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "metric xnn original Allegro\n", "----------------------------------------------------\n", "energy RMSE [meV/atom] 15.81 17.37\n", "energy MAE [meV/atom] 11.66 11.57\n", "force RMSE [meV/Å] 1.67 2.08\n", "force MAE [meV/Å] 1.07 1.47\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_allegro(model):\n", " model.eval(); Ep, Er, na, Fp, Fr = [], [], [], [], []\n", " for s, d in zip(test_structs, al_test):\n", " b = next(iter(NequipDataLoader([d], batch_size=1))).to(DEVICE)\n", " out = model(AtomicData.to_AtomicDataDict(b))\n", " Ep.append(float(out[\"total_energy\"].sum().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 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_a = metrics(*eval_allegro(al_model))\n", "print(f\"{'metric':<24}{'xnn':>10}{'original Allegro':>18}\")\n", "print(\"-\" * 52)\n", "for k, lbl in [(\"e_rmse\", \"energy RMSE [meV/atom]\"), (\"e_mae\", \"energy MAE [meV/atom]\"),\n", " (\"f_rmse\", \"force RMSE [meV/Å]\"), (\"f_mae\", \"force MAE [meV/Å]\")]:\n", " print(f\"{lbl:<24}{res_x[k]:>10.2f}{res_a[k]:>18.2f}\")" ] }, { "cell_type": "markdown", "id": "616bf6a9", "metadata": {}, "source": [ "### Side-by-side parity plots\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "270c1981", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:37:23.911457Z", "iopub.status.busy": "2026-07-20T04:37:23.911334Z", "iopub.status.idle": "2026-07-20T04:37:24.938431Z", "shell.execute_reply": "2026-07-20T04:37:24.937515Z" } }, "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=4000, replace=False)\n", "for col, (res, name) in enumerate([(res_x, \"xnn\"), (res_a, \"original Allegro\")]):\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/Å]\"); a1.set_ylabel(\"pred force [eV/Å]\")\n", " a1.set_title(f\"{name}: forces (RMSE {res['f_rmse']:.1f} meV/Å)\")\n", "plt.tight_layout(); plt.savefig(\"argon_parity_xnn_vs_allegro.png\", dpi=120); plt.show()" ] }, { "cell_type": "markdown", "id": "20e0a58c", "metadata": {}, "source": [ "## 6. `xnn` ASE calculator (deployment)\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "97e0cb74", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:37:24.940175Z", "iopub.status.busy": "2026-07-20T04:37:24.940098Z", "iopub.status.idle": "2026-07-20T04:37:25.171621Z", "shell.execute_reply": "2026-07-20T04:37:25.170631Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ASE single point: E = -27.1625 eV | max|F| = 0.0874 eV/Å\n", "reference : E = -31.0395 eV\n" ] } ], "source": [ "from ase import Atoms\n", "from xnn.common.deploy import XNNCalculator\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", "print(f\"ASE single point: E = {atoms.get_potential_energy():.4f} eV | \"\n", " f\"max|F| = {np.abs(atoms.get_forces()).max():.4f} eV/Å\")\n", "print(f\"reference : E = {s['energy']:.4f} eV\")" ] }, { "cell_type": "markdown", "id": "c99e69e2", "metadata": {}, "source": [ "## Summary: every stage compared\n", "\n", "| stage | result |\n", "|---|---|\n", "| **Data → graphs** | identical edge sets in both pipelines |\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` Allegro is a faithful, dependency-light (only `e3nn`)\n", "re-implementation of the original Allegro; residual metric differences come\n", "only from independent initialisation and shuffling. The companion notebook\n", "`allegro_argon_density_md.ipynb` runs NPT MD with both codes.\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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 }