{ "cells": [ { "cell_type": "markdown", "id": "c329799f", "metadata": {}, "source": [ "# Training & testing PhysNet on Argon MD data: `xnn` vs the original PhysNet, step by step\n", "\n", "This notebook runs a **complete end-to-end pipeline on a realistic Argon\n", "dataset, twice**, once with the `xnn` PhysNet (PyTorch) and once with the\n", "**original** TF1 PhysNet, and **compares the two at every stage**: data →\n", "graphs, model build, *same-function* weight transplant, training (same data /\n", "loss / optimiser / schedule / split), and held-out test metrics. Same protocol\n", "as the MACE / NequIP / Allegro / CACE companions.\n", "\n", "> Notebook `../../fidelity_checks/physnet_verification.ipynb` proves the two are the\n", "> same function to float64 machine precision; here we confirm it on the actual\n", "> data and compare full training pipelines. Everything runs in float32 on the\n", "> CPU (the reference TF1 code path); the original consumes the **same periodic\n", "> edge lists** through its `idx_i/idx_j/offsets` placeholders; its own data\n", "> pipeline (`DataContainer`) handles molecular ``.npz`` datasets only." ] }, { "cell_type": "markdown", "id": "6f4c9030", "metadata": {}, "source": [ "## 0. Setup: TF1 compatibility mode, float32, one process for both codes" ] }, { "cell_type": "code", "execution_count": 1, "id": "e779ae5a", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:40:30.785673Z", "iopub.status.busy": "2026-07-20T04:40:30.785538Z", "iopub.status.idle": "2026-07-20T04:40:34.401480Z", "shell.execute_reply": "2026-07-20T04:40:34.400633Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xnn: 0.1.0 | tensorflow: 2.21.0 | torch: 2.12.1+cpu\n" ] } ], "source": [ "# silence the expected warnings / TF chatter\n", "import logging, os, warnings\n", "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"3\"\n", "logging.disable(logging.WARNING)\n", "warnings.filterwarnings(\"ignore\")\n", "\n", "import subprocess, sys, tempfile\n", "import numpy as np\n", "\n", "# ---- the original TF1 PhysNet (cloned on demand) ----\n", "UPSTREAM = os.environ.get(\"PHYSNET_UPSTREAM_PATH\",\n", " os.path.join(tempfile.gettempdir(), \"physnet-upstream\"))\n", "if not os.path.isdir(UPSTREAM):\n", " subprocess.run([\"git\", \"clone\", \"--depth\", \"1\",\n", " \"https://github.com/MMunibas/PhysNet\", UPSTREAM], check=True)\n", "\n", "import tensorflow.compat.v1 as tf\n", "tf.disable_eager_execution()\n", "tf.get_logger().setLevel(\"ERROR\")\n", "sys.modules[\"tensorflow\"] = tf # upstream modules do `import tensorflow as tf`\n", "# upstream applies dropout with keep_prob = 1.0 (identity); its float32\n", "# placeholder trips TF2's dtype check in float64 graphs\n", "tf.nn.dropout = lambda x, keep_prob=None, **kw: x\n", "\n", "sys.path.insert(0, UPSTREAM)\n", "import neural_network.NeuralNetwork as _nnmod\n", "from neural_network.NeuralNetwork import NeuralNetwork\n", "\n", "import time\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", "import xnn\n", "DATA = \"../../../datasets/argon_md\" # shared with all example series\n", "print(\"xnn:\", xnn.__version__, \"| tensorflow:\", tf.__version__, \"| torch:\", torch.__version__)" ] }, { "cell_type": "markdown", "id": "e32188e2", "metadata": {}, "source": [ "## 1. Load the data and the reference energy $E_0$\n", "\n", "$E_0$ goes into PhysNet's per-element ``Eshift`` table on both sides (upstream\n", "initializes it by dataset regression; xnn loads it via ``atomic_energies``)." ] }, { "cell_type": "code", "execution_count": 2, "id": "25af8053", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:40:34.403134Z", "iopub.status.busy": "2026-07-20T04:40:34.403017Z", "iopub.status.idle": "2026-07-20T04:40:37.539089Z", "shell.execute_reply": "2026-07-20T04:40:37.538261Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "train 197 / test 48 configs (dropped 3/2 edgeless) | E0: {18: 0.0}\n" ] } ], "source": [ "from xnn.common.data import AtomicDataset, load_dataset\n", "\n", "SR_CUT, LR_CUT, SPECIES = 6.0, 9.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, cutoff):\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, LR_CUT)\n", "test_structs, n_te = with_edges(test_structs, LR_CUT)\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": "ea3e777c", "metadata": {}, "source": [ "## 2. Graphs for both pipelines and one shared split\n", "\n", "The xnn neighbour list (radius ``lr_cutoff`` = 9 Å; the NN features vanish\n", "beyond ``sr_cut`` = 6 Å by construction, the longer list feeds the long-range\n", "terms) is converted once into the original's ``(Z, R, idx_i, idx_j, offsets,\n", "batch_seg)`` arrays. ``tf.segment_sum`` needs ``idx_i`` sorted, so edges are\n", "sorted by center." ] }, { "cell_type": "code", "execution_count": 3, "id": "cac3b1b5", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:40:37.541254Z", "iopub.status.busy": "2026-07-20T04:40:37.541125Z", "iopub.status.idle": "2026-07-20T04:40:38.946682Z", "shell.execute_reply": "2026-07-20T04:40:38.945839Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "total edges (9 A list): 5308651 (identical arrays feed both codes)\n", "train 178 / val 19 configs (identical for both models)\n" ] } ], "source": [ "xnn_train = AtomicDataset(train_structs, LR_CUT)\n", "xnn_test = AtomicDataset(test_structs, LR_CUT)\n", "\n", "def to_feed(g, s):\n", " n = len(s[\"atomic_numbers\"])\n", " ii, jj = g.edge_index[1].numpy(), g.edge_index[0].numpy()\n", " cell = torch.tensor(s[\"cell\"], dtype=torch.get_default_dtype())\n", " offsets = (g.cell_shifts.to(cell.dtype) @ cell).numpy()\n", " # tf.segment_sum sizes its output by max(idx_i)+1, so atoms without any\n", " # edge (a few vaporised frames have them) need one dummy far-away edge --\n", " # exactly zero contribution: phi(r), the switched Coulomb and D3 are all\n", " # hard-zero beyond lr_cut\n", " missing = np.setdiff1d(np.arange(n), ii)\n", " if len(missing):\n", " ii = np.concatenate([ii, missing])\n", " jj = np.concatenate([jj, (missing + 1) % n])\n", " far = np.zeros((len(missing), 3)); far[:, 0] = 1e3\n", " offsets = np.concatenate([offsets, far])\n", " order = np.argsort(ii, kind=\"stable\") # segment_sum wants sorted idx_i\n", " # TF computes Dij = |R[i] - (R[j] + offset)|, while the xnn edge vector is\n", " # r_i - r_j + shift@cell, so the offset TF needs is the NEGATED cell shift\n", " offsets = -offsets\n", " return {\"Z\": g.atomic_numbers.numpy(), \"R\": s[\"pos\"].astype(np.float32),\n", " \"idx_i\": ii[order], \"idx_j\": jj[order],\n", " \"offsets\": offsets[order].astype(np.float32),\n", " \"E\": np.float32(s[\"energy\"]), \"F\": s[\"forces\"].astype(np.float32)}\n", "\n", "tf_train = [to_feed(xnn_train[i], train_structs[i]) for i in range(len(train_structs))]\n", "tf_test = [to_feed(xnn_test[i], test_structs[i]) for i in range(len(test_structs))]\n", "print(f\"total edges (9 A list): {sum(len(f['idx_i']) for f in tf_train)} \"\n", " \"(identical arrays feed both codes)\")\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": "9970d9a5", "metadata": {}, "source": [ "## 3. Build both models with identical hyper-parameters\n", "\n", "A small-but-real PhysNet (CPU-friendly): $F=64$, $K=32$, 3 modules, residual\n", "depths 2/3/1, electrostatics + D3 on, ``lr_cut`` = 9 Å." ] }, { "cell_type": "code", "execution_count": 4, "id": "0ed49e29", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:40:38.948480Z", "iopub.status.busy": "2026-07-20T04:40:38.948372Z", "iopub.status.idle": "2026-07-20T04:40:45.462928Z", "shell.execute_reply": "2026-07-20T04:40:45.461882Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "parameters: xnn 200448 | original 200448\n" ] } ], "source": [ "from xnn.common.config import from_dict\n", "from xnn.common.models import build_model, ForceStressOutput\n", "\n", "F_DIM, K, NB, NRA, NRI, NRO = 64, 32, 3, 2, 3, 1\n", "EW, FW, LR, BS, EPOCHS = 1.0, 100.0, 1e-3, 10, 40\n", "\n", "core = from_dict({\n", " \"model\": {\"name\": \"physnet\", \"cutoff\": SR_CUT, \"n_features\": F_DIM,\n", " \"n_rbf\": K, \"n_interactions\": NB,\n", " \"lr_cutoff\": LR_CUT, \"num_residual_atomic\": NRA,\n", " \"num_residual_interaction\": NRI, \"num_residual_output\": NRO,\n", " \"species\": SPECIES, \"atomic_energies\": [E0[18]]},\n", " \"data\": {\"batch_size\": BS},\n", " \"optim\": {\"lr\": LR, \"epochs\": EPOCHS, \"energy_weight\": EW, \"force_weight\": FW,\n", " \"scheduler\": \"plateau\"},\n", " \"device\": \"cpu\", \"seed\": 0, \"output_dir\": \"runs/argon_xnn\",\n", "})\n", "torch.manual_seed(0)\n", "xnn_model = ForceStressOutput(build_model(core.model))\n", "\n", "def build_tf_graph():\n", " \"\"\"The original PhysNet as a TF1 training graph fed by placeholders.\"\"\"\n", " nn = NeuralNetwork(F=F_DIM, K=K, sr_cut=SR_CUT, lr_cut=LR_CUT, num_blocks=NB,\n", " num_residual_atomic=NRA, num_residual_interaction=NRI,\n", " num_residual_output=NRO, use_electrostatic=True,\n", " use_dispersion=True, Eshift=E0[18], scope=\"nn\", seed=0)\n", " ph = {\"Z\": tf.placeholder(tf.int32, [None]), \"R\": tf.placeholder(tf.float32, [None, 3]),\n", " \"idx_i\": tf.placeholder(tf.int32, [None]), \"idx_j\": tf.placeholder(tf.int32, [None]),\n", " \"offsets\": tf.placeholder(tf.float32, [None, 3]),\n", " \"batch_seg\": tf.placeholder(tf.int32, [None]),\n", " \"E_ref\": tf.placeholder(tf.float32, [None]), \"F_ref\": tf.placeholder(tf.float32, [None, 3]),\n", " \"lr\": tf.placeholder(tf.float32, [])}\n", " Ea, Qa, Dij, _ = nn.atomic_properties(ph[\"Z\"], ph[\"R\"], ph[\"idx_i\"], ph[\"idx_j\"],\n", " offsets=ph[\"offsets\"])\n", " E = nn.energy_from_atomic_properties(Ea, Qa, Dij, ph[\"Z\"], ph[\"idx_i\"], ph[\"idx_j\"],\n", " batch_seg=ph[\"batch_seg\"])\n", " E = tf.reshape(E, [-1])\n", " Fp = -tf.gradients(tf.reduce_sum(E), ph[\"R\"])[0]\n", " n_at = tf.segment_sum(tf.ones_like(ph[\"batch_seg\"], tf.float32), ph[\"batch_seg\"])\n", " loss = (EW * tf.reduce_mean(((E - ph[\"E_ref\"]) / n_at) ** 2)\n", " + FW * tf.reduce_mean((Fp - ph[\"F_ref\"]) ** 2))\n", " train_op = tf.train.AdamOptimizer(ph[\"lr\"]).minimize(loss)\n", " return nn, ph, E, Fp, loss, train_op\n", "\n", "tf.reset_default_graph()\n", "tf_nn, ph, E_op, F_op, loss_op, train_op = build_tf_graph()\n", "sess = tf.Session()\n", "sess.run(tf.global_variables_initializer())\n", "\n", "p_x = sum(p.numel() for p in xnn_model.parameters())\n", "p_t = int(sum(np.prod(v.shape.as_list()) for v in tf.trainable_variables()))\n", "print(f\"parameters: xnn {p_x} | original {p_t}\")\n", "\n", "def make_feed(frames, lr=LR):\n", " Z = np.concatenate([f[\"Z\"] for f in frames])\n", " R = np.concatenate([f[\"R\"] for f in frames])\n", " off_at, off_ed = 0, []\n", " ii, jj, offs, seg = [], [], [], []\n", " for k, f in enumerate(frames):\n", " ii.append(f[\"idx_i\"] + off_at); jj.append(f[\"idx_j\"] + off_at)\n", " offs.append(f[\"offsets\"]); seg.append(np.full(len(f[\"Z\"]), k))\n", " off_at += len(f[\"Z\"])\n", " return {ph[\"Z\"]: Z, ph[\"R\"]: R, ph[\"idx_i\"]: np.concatenate(ii),\n", " ph[\"idx_j\"]: np.concatenate(jj), ph[\"offsets\"]: np.concatenate(offs),\n", " ph[\"batch_seg\"]: np.concatenate(seg),\n", " ph[\"E_ref\"]: np.array([f[\"E\"] for f in frames]),\n", " ph[\"F_ref\"]: np.concatenate([f[\"F\"] for f in frames]), ph[\"lr\"]: lr}" ] }, { "cell_type": "markdown", "id": "867e932e", "metadata": {}, "source": [ "## 3b. Are they the *same function*? Weight transplant on the Argon data\n", "\n", "Copy every TF variable into the xnn model and compare on real **periodic**\n", "Argon test configurations (float32 round-off; ~1e-15 in float64, notebook 01)." ] }, { "cell_type": "code", "execution_count": 5, "id": "505e19a8", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:40:45.465128Z", "iopub.status.busy": "2026-07-20T04:40:45.465014Z", "iopub.status.idle": "2026-07-20T04:41:12.735630Z", "shell.execute_reply": "2026-07-20T04:41:12.734784Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "transplanted models on Argon test configs (float32):\n", " max |E_xnn - E_tf| = 3.05e-05 eV | max |F_xnn - F_tf| = 2.87e-06 eV/A\n" ] } ], "source": [ "def transplant_tf_to_torch(x, vals, num_blocks, scope=\"nn\"):\n", " \"\"\"Copy every variable of the original TF PhysNet into the xnn PhysNet.\"\"\"\n", " import torch\n", " def g(name): return torch.tensor(np.asarray(vals[f\"{scope}/{name}:0\"]))\n", " with torch.no_grad():\n", " x.embeddings.copy_(g(\"embeddings\"))\n", " x.rbf_layer.centers.copy_(g(\"rbf_layer/centers\"))\n", " x.rbf_layer.widths.copy_(g(\"rbf_layer/widths\"))\n", " x.Eshift.copy_(g(\"Eshift\")); x.Escale.copy_(g(\"Escale\"))\n", " x.Qshift.copy_(g(\"Qshift\")); x.Qscale.copy_(g(\"Qscale\"))\n", " x._s6.copy_(g(\"s6\")); x._s8.copy_(g(\"s8\"))\n", " x._a1.copy_(g(\"a1\")); x._a2.copy_(g(\"a2\"))\n", " def cd(dst, sc, bias=True):\n", " dst.weight.copy_(g(f\"{sc}/W\"))\n", " if bias: dst.bias.copy_(g(f\"{sc}/b\"))\n", " def cr(dst, sc):\n", " cd(dst.dense, f\"{sc}/dense\"); cd(dst.residual, f\"{sc}/residual\")\n", " for b in range(num_blocks):\n", " ib, sc = x.interaction_blocks[b], f\"interaction_block{b}\"\n", " il = ib.interaction\n", " cd(il.k2f, f\"{sc}/interaction_layer/k2f\", bias=False)\n", " cd(il.dense_i, f\"{sc}/interaction_layer/dense_i\")\n", " cd(il.dense_j, f\"{sc}/interaction_layer/dense_j\")\n", " for k, r in enumerate(il.residuals):\n", " cr(r, f\"{sc}/interaction_layer/residual_layer{k}\")\n", " cd(il.dense, f\"{sc}/interaction_layer/dense\")\n", " il.u.copy_(g(f\"{sc}/interaction_layer/u\"))\n", " for k, r in enumerate(ib.residuals):\n", " cr(r, f\"{sc}/residual_layer{k}\")\n", " ob = x.output_blocks[b]\n", " for k, r in enumerate(ob.residuals):\n", " cr(r, f\"output_block{b}/residual_layer{k}\")\n", " ob.dense.weight.copy_(g(f\"output_block{b}/dense_layer/W\"))\n", "\n", "vals = {v.name: sess.run(v) for v in tf.global_variables()}\n", "transplant_tf_to_torch(xnn_model.model, vals, NB)\n", "\n", "dE, dF = [], []\n", "for k in range(8):\n", " out = xnn_model(xnn_test[k])\n", " E_t, F_t = sess.run([E_op, F_op], make_feed([tf_test[k]]))\n", " dE.append(abs(float(out[\"energy\"]) - float(E_t[0])))\n", " dF.append(np.abs(out[\"forces\"].detach().numpy() - F_t).max())\n", "print(\"transplanted models on Argon test configs (float32):\")\n", "print(f\" max |E_xnn - E_tf| = {max(dE):.2e} eV | max |F_xnn - F_tf| = {max(dF):.2e} eV/A\")\n", "\n", "# re-initialize the xnn model freshly for the fair training comparison\n", "torch.manual_seed(0)\n", "xnn_model = ForceStressOutput(build_model(core.model))" ] }, { "cell_type": "markdown", "id": "c50bc579", "metadata": {}, "source": [ "## 4a. Train the `xnn` model (`xnn.train.Trainer`)" ] }, { "cell_type": "code", "execution_count": 6, "id": "4a06aa1f", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:41:12.737409Z", "iopub.status.busy": "2026-07-20T04:41:12.737282Z", "iopub.status.idle": "2026-07-20T04:49:39.300633Z", "shell.execute_reply": "2026-07-20T04:49:39.299752Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xnn: 40 epochs in 506.0 s | final train 8.6197e-04 val 4.3481e-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)\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": "03bbb8a8", "metadata": {}, "source": [ "## 4b. Train the **original PhysNet**: same data, loss, optimiser, schedule\n", "\n", "A transparent TF1 loop (the packaged route is upstream ``train.py``); the\n", "plateau schedule mirrors ``torch.optim.lr_scheduler.ReduceLROnPlateau``'s\n", "defaults." ] }, { "cell_type": "code", "execution_count": 7, "id": "f369c825", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:49:39.302215Z", "iopub.status.busy": "2026-07-20T04:49:39.302112Z", "iopub.status.idle": "2026-07-20T04:57:56.983458Z", "shell.execute_reply": "2026-07-20T04:57:56.982244Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "original: 40 epochs in 497.7 s | final train 8.0836e-04 val 4.9075e-04\n" ] } ], "source": [ "rng_ep = np.random.default_rng(0)\n", "hist_t = {\"train\": [], \"val\": []}\n", "lr_now, best_val, bad = LR, np.inf, 0\n", "t0 = time.time()\n", "for epoch in range(EPOCHS):\n", " order = rng_ep.permutation(len(train_idx))\n", " tl = 0.0; nb = 0\n", " for s in range(0, len(order), BS):\n", " frames = [tf_train[train_idx[i]] for i in order[s:s + BS]]\n", " _, l = sess.run([train_op, loss_op], make_feed(frames, lr=lr_now))\n", " tl += float(l); nb += 1\n", " vl = 0.0; nv = 0\n", " for s in range(0, len(val_idx), BS):\n", " frames = [tf_train[i] for i in val_idx[s:s + BS]]\n", " vl += float(sess.run(loss_op, make_feed(frames))); nv += 1\n", " tl /= nb; vl /= nv\n", " hist_t[\"train\"].append(tl); hist_t[\"val\"].append(vl)\n", " # ReduceLROnPlateau(factor=0.1, patience=10) in five lines\n", " if vl < best_val: best_val, bad = vl, 0\n", " else:\n", " bad += 1\n", " if bad > 10: lr_now, bad = lr_now * 0.1, 0\n", "t_t = time.time() - t0\n", "print(f\"original: {EPOCHS} epochs in {t_t:.1f} s | \"\n", " f\"final train {hist_t['train'][-1]:.4e} val {hist_t['val'][-1]:.4e}\")" ] }, { "cell_type": "markdown", "id": "0526f75f", "metadata": {}, "source": [ "### Training-loss curves: both models" ] }, { "cell_type": "code", "execution_count": 8, "id": "bc67ec2f", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:57:56.985696Z", "iopub.status.busy": "2026-07-20T04:57:56.985569Z", "iopub.status.idle": "2026-07-20T04:57:58.556032Z", "shell.execute_reply": "2026-07-20T04:57:58.554977Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "training time (CPU): xnn 506s original TF1 498s\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 (PyTorch)\")\n", " a.plot(ep, hist_t[key], label=\"original (TF1)\")\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 (CPU): xnn {t_x:.0f}s original TF1 {t_t:.0f}s\")" ] }, { "cell_type": "markdown", "id": "b67fc2a6", "metadata": {}, "source": [ "## 5. Evaluate both trained models on the held-out test set" ] }, { "cell_type": "code", "execution_count": 9, "id": "f121993c", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:57:58.559115Z", "iopub.status.busy": "2026-07-20T04:57:58.558957Z", "iopub.status.idle": "2026-07-20T04:58:01.953790Z", "shell.execute_reply": "2026-07-20T04:58:01.952738Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "metric xnn original\n", "------------------------------------------------\n", "energy RMSE [meV/atom] 17.55 16.35\n", "energy MAE [meV/atom] 11.91 11.81\n", "force RMSE [meV/A] 3.03 3.14\n", "force MAE [meV/A] 1.81 1.96\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])\n", " Ep.append(float(out[\"energy\"].detach())); Er.append(s[\"energy\"]); na.append(len(s[\"atomic_numbers\"]))\n", " Fp.append(out[\"forces\"].detach().numpy()); Fr.append(s[\"forces\"])\n", " return map(np.array, (Ep, Er, na)), np.concatenate(Fp), np.concatenate(Fr)\n", "\n", "def eval_tf():\n", " Ep, Er, na, Fp, Fr = [], [], [], [], []\n", " for s, f in zip(test_structs, tf_test):\n", " E_t, F_t = sess.run([E_op, F_op], make_feed([f]))\n", " Ep.append(float(E_t[0])); Er.append(s[\"energy\"]); na.append(len(s[\"atomic_numbers\"]))\n", " Fp.append(F_t); 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_t = metrics(*eval_tf())\n", "print(f\"{'metric':<24}{'xnn':>10}{'original':>14}\")\n", "print(\"-\" * 48)\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_t[k]:>14.2f}\")" ] }, { "cell_type": "markdown", "id": "12b16cd0", "metadata": {}, "source": [ "### Side-by-side parity plots" ] }, { "cell_type": "code", "execution_count": 10, "id": "64b1a121", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:58:01.956334Z", "iopub.status.busy": "2026-07-20T04:58:01.956205Z", "iopub.status.idle": "2026-07-20T04:58:03.111109Z", "shell.execute_reply": "2026-07-20T04:58:03.110087Z" } }, "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_t, \"original PhysNet\")]):\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_physnet.png\", dpi=120); plt.show()" ] }, { "cell_type": "markdown", "id": "a1919cab", "metadata": {}, "source": [ "## 6. `xnn` ASE calculator (deployment)" ] }, { "cell_type": "code", "execution_count": 11, "id": "43021125", "metadata": { "execution": { "iopub.execute_input": "2026-07-20T04:58:03.113681Z", "iopub.status.busy": "2026-07-20T04:58:03.113571Z", "iopub.status.idle": "2026-07-20T04:58:03.229662Z", "shell.execute_reply": "2026-07-20T04:58:03.228917Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ASE single point: E = -29.7783 eV | max|F| = 0.0866 eV/A\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, cutoff=trainer.model.model.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/A\")\n", "print(f\"reference : E = {s['energy']:.4f} eV\")\n", "sess.close()" ] }, { "cell_type": "markdown", "id": "f51fdac0", "metadata": {}, "source": [ "## Summary: every stage compared\n", "\n", "| stage | result |\n", "|---|---|\n", "| **Data → graphs** | one xnn neighbour list feeds both codes (the original's own pipeline is molecular-``.npz``-only) |\n", "| **Model build** | identical architecture and parameter count |\n", "| **Same function?** | weight transplant → **identical E and F on periodic Argon** (float32 round-off) |\n", "| **Training** | same data / loss / Adam / plateau schedule → comparable loss curves |\n", "| **Test accuracy** | energy and force RMSE/MAE agree between the two implementations |\n", "\n", "The `xnn` PhysNet is the original PhysNet in pure PyTorch; residual metric\n", "differences come from independent initialisation and shuffling. The companion\n", "notebook `physnet_argon_density_md.ipynb` takes it to molecular dynamics." ] } ], "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 }