Sync mmml checkpoints, configurations, and run metadata (part 14)

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/BASE

@@ -0,0 +1 @@
+base 3af540f746d97bdba82c24173777d0fbb443bad2 branch spice-alpha-full

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/mmml/data/spice_alpha_ragged.py

@@ -0,0 +1,193 @@
+"""Ragged (unpadded) SPICE-α conversion for full-dataset efield training.
+
+The padded converter (:mod:`mmml.data.spice_alpha`) pads every frame to the
+largest system, which for full SPICE-α (3-110 atoms, 1.8M frames) is mostly
+padding. Here atoms are stored concatenated with per-frame offsets:
+
+    Z (A,) int8, R (A, 3) float32 Å, F (A, 3) float32 eV/Å      A = total atoms
+    N (n,) int16 atoms per frame, offsets (n + 1,) int64
+    E (n,) float64 eV, D (n, 3) float32 e·Å, Q (n,) float32 e,
+    polar (n, 3, 3) float32 Bohr³, mol (n,) int64 molecule id, subset (n,) int8
+
+Molecule ids let :func:`split_ragged` hold out whole molecules, so conformers
+of a training molecule never appear in validation/test.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Mapping, Sequence
+
+import numpy as np
+
+from mmml.data.spice_alpha import iter_spice_alpha_frames
+from mmml.data.units import polar_e_angstrom2_per_volt_to_bohr3
+
+RAGGED_FORMAT = "mmml-spice-alpha-ragged-v1"
+PER_FRAME_KEYS = ("N", "E", "D", "Q", "polar", "mol", "subset")
+PER_ATOM_KEYS = ("Z", "R", "F")
+
+# SPICE-α file stem -> subset name (MACE-MDP Fig. 2 naming)
+SUBSETS: dict[str, str] = {
+    "DES370K_Dimers": "dimers",
+    "DES370K_Monomers": "monomers",
+    "SPICE_PubChem_1_2": "pubchem",
+    "SPICE_PubChem_3_4": "pubchem",
+    "SPICE_PubChem_5_6": "pubchem",
+    "SPICE_PubChem_7_8": "pubchem",
+    "SPICE_PubChem_9_10": "pubchem",
+    "SPICE_Solvated_PubChem": "solvated_pubchem",
+    "SPICE_Water": "water",
+    "SPICE_amino_acid_ligand": "amino_acid_ligand",
+    "SPICE_di_peptide": "dipeptides",
+    "SPICE_solvated_amino_acid": "solvated_amino_acid",
+}
+SUBSET_IDS: dict[str, int] = {name: i for i, name in enumerate(sorted(set(SUBSETS.values())))}
+
+
+def convert_hdf5_ragged(
+    path: Path | str,
+    out: Path | str,
+    *,
+    mol_id_base: int,
+    neutral_tol: float = 0.5,
+    max_abs_polar_bohr3: float = 1.0e4,
+) -> dict[str, int]:
+    """Convert one SPICE-α HDF5 file to a ragged NPZ; returns frame counts.
+
+    Keeps neutral frames only (|sum MBIS charges| < ``neutral_tol``, as MACE-MDP)
+    and drops frames with non-finite or corrupt (|α_ij| > ``max_abs_polar_bohr3``)
+    polarizabilities or non-finite dipoles.
+    """
+    import h5py
+
+    path = Path(path)
+    subset = SUBSETS[path.stem]
+    Z, R, F = [], [], []
+    N, E, D, Q, P, mol = [], [], [], [], [], []
+    group_ids: dict[str, int] = {}
+    stats = {"seen": 0, "charged": 0, "bad_polar": 0, "bad_dipole": 0, "kept": 0}
+    with h5py.File(path, "r") as h5:
+        for fr in iter_spice_alpha_frames(h5, neutral_only=False):
+            stats["seen"] += 1
+            if fr.Q is not None and abs(fr.Q) > neutral_tol:
+                stats["charged"] += 1
+                continue
+            if fr.polar is None:
+                stats["bad_polar"] += 1
+                continue
+            polar = polar_e_angstrom2_per_volt_to_bohr3(np.asarray(fr.polar, dtype=np.float64))
+            if not np.isfinite(polar).all() or np.abs(polar).max() > max_abs_polar_bohr3:
+                stats["bad_polar"] += 1
+                continue
+            if not np.isfinite(fr.D).all():
+                stats["bad_dipole"] += 1
+                continue
+            gid = group_ids.setdefault(fr.group, mol_id_base + len(group_ids))
+            Z.append(fr.Z.astype(np.int8))
+            R.append(fr.R.astype(np.float32))
+            F.append(fr.F.astype(np.float32))
+            N.append(fr.Z.shape[0])
+            E.append(fr.E)
+            D.append(fr.D)
+            Q.append(0.0 if fr.Q is None else fr.Q)
+            P.append(polar)
+            mol.append(gid)
+            stats["kept"] += 1
+    n = len(N)
+    out_arrays = {
+        "Z": np.concatenate(Z) if n else np.zeros((0,), np.int8),
+        "R": np.concatenate(R) if n else np.zeros((0, 3), np.float32),
+        "F": np.concatenate(F) if n else np.zeros((0, 3), np.float32),
+        "N": np.asarray(N, dtype=np.int16),
+        "E": np.asarray(E, dtype=np.float64),
+        "D": np.asarray(D, dtype=np.float32).reshape(n, 3),
+        "Q": np.asarray(Q, dtype=np.float32),
+        "polar": np.asarray(P, dtype=np.float32).reshape(n, 3, 3),
+        "mol": np.asarray(mol, dtype=np.int64),
+        "subset": np.full((n,), SUBSET_IDS[subset], dtype=np.int8),
+    }
+    meta = {"format": RAGGED_FORMAT, "source": path.name, "subset": subset,
+            "subset_ids": SUBSET_IDS, "n_molecules": len(group_ids), "stats": stats,
+            "units": {"R": "angstrom", "E": "ev", "F": "ev_angstrom", "D": "e_angstrom",
+                      "Q": "e", "polar": "bohr3"}}
+    np.savez(out, **out_arrays, meta=np.array(json.dumps(meta)))
+    return stats
+
+
+def offsets_from_counts(N: np.ndarray) -> np.ndarray:
+    off = np.zeros((len(N) + 1,), dtype=np.int64)
+    np.cumsum(np.asarray(N, dtype=np.int64), out=off[1:])
+    return off
+
+
+def load_ragged(paths: Sequence[Path | str]) -> dict[str, np.ndarray]:
+    """Concatenate ragged NPZ shards; adds ``offsets``."""
+    parts = [np.load(p) for p in paths]
+    data = {k: np.concatenate([p[k] for p in parts]) for k in PER_ATOM_KEYS + PER_FRAME_KEYS}
+    data["offsets"] = offsets_from_counts(data["N"])
+    return data
+
+
+def take_frames(data: Mapping[str, np.ndarray], idx: np.ndarray) -> dict[str, np.ndarray]:
+    """Subset a ragged dict by frame indices (keeps order of ``idx``)."""
+    idx = np.asarray(idx, dtype=np.int64)
+    off = data["offsets"]
+    atom_idx = np.concatenate([np.arange(off[i], off[i + 1]) for i in idx]) if len(idx) else np.zeros((0,), np.int64)
+    out = {k: np.asarray(data[k])[atom_idx] for k in PER_ATOM_KEYS}
+    out.update({k: np.asarray(data[k])[idx] for k in PER_FRAME_KEYS})
+    out["offsets"] = offsets_from_counts(out["N"])
+    return out
+
+
+def split_ragged(
+    data: Mapping[str, np.ndarray],
+    *,
+    valid_frac: float = 0.05,
+    test_frac: float = 0.05,
+    seed: int = 0,
+    min_molecules_for_mol_split: int = 50,
+) -> dict[str, np.ndarray]:
+    """Frame indices per split, holding out whole molecules.
+
+    Subsets with fewer than ``min_molecules_for_mol_split`` molecules (SPICE
+    Water is one 1000-conformer group) are split by frame instead.
+    """
+    rng = np.random.default_rng(seed)
+    subset = np.asarray(data["subset"])
+    mol = np.asarray(data["mol"])
+    idx = {"train": [], "valid": [], "test": []}
+    for s in np.unique(subset):
+        frames = np.flatnonzero(subset == s)
+        mols = np.unique(mol[frames])
+        if len(mols) >= min_molecules_for_mol_split:
+            perm = rng.permutation(mols)
+            n_v = max(1, int(round(len(mols) * valid_frac)))
+            n_t = max(1, int(round(len(mols) * test_frac)))
+            role = {m: "valid" for m in perm[:n_v]}
+            role.update({m: "test" for m in perm[n_v:n_v + n_t]})
+            for f in frames:
+                idx[role.get(mol[f], "train")].append(f)
+        else:
+            perm = rng.permutation(frames)
+            n_v = int(round(len(frames) * valid_frac))
+            n_t = int(round(len(frames) * test_frac))
+            idx["valid"].extend(perm[:n_v])
+            idx["test"].extend(perm[n_v:n_v + n_t])
+            idx["train"].extend(perm[n_v + n_t:])
+    return {k: np.sort(np.asarray(v, dtype=np.int64)) for k, v in idx.items()}
+
+
+def fit_atomic_energy_refs(data: Mapping[str, np.ndarray], max_z: int = 119) -> np.ndarray:
+    """Least-squares per-element reference energies e_Z (eV), indexed by Z."""
+    off = data["offsets"]
+    frame_of_atom = np.repeat(np.arange(len(data["N"])), data["N"].astype(np.int64))
+    counts = np.zeros((len(data["N"]), max_z), dtype=np.float64)
+    np.add.at(counts, (frame_of_atom, data["Z"].astype(np.int64)), 1.0)
+    present = counts.sum(axis=0) > 0
+    sol, *_ = np.linalg.lstsq(counts[:, present], np.asarray(data["E"], np.float64), rcond=None)
+    e_ref = np.zeros((max_z,), dtype=np.float64)
+    e_ref[present] = sol
+    assert off[-1] == len(data["Z"])
+    return e_ref

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/mmml/models/efield/packed.py

@@ -0,0 +1,258 @@
+"""Packed variable-size batches for full SPICE-α efield training.
+
+Instead of padding every frame to the largest system, each batch concatenates
+whole frames until an atom / edge / molecule budget is reached, then pads to
+the fixed budget so XLA compiles one shape. Edges are an intra-frame
+neighbour list within ``cutoff`` (directed, i != j), built on the CPU.
+
+Layout of a packed batch (M molecule slots, A atoms, E edges):
+  atomic_numbers (A,) int32, positions (A, 3), forces (A, 3), batch_segments (A,)
+  dst_idx_flat / src_idx_flat (E,), electric_field (M, 3), energies (M,),
+  dipoles (M, 3), polar (M, 3, 3), mol_mask (M,), subset (M,)
+The last molecule slot and the last atom are always padding; padding atoms
+have Z = 0 and padding edges are (A-1, A-1), which the model masks out.
+"""
+
+from __future__ import annotations
+
+import queue
+import threading
+from dataclasses import dataclass
+from typing import Iterator, Mapping
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+
+from mmml.models.efield.model_functions import predicted_polarizability_bohr3
+
+
+@dataclass(frozen=True)
+class PackSpec:
+    max_molecules: int = 256   # M, including one padding slot
+    max_atoms: int = 4096      # A, including at least one padding atom
+    max_edges: int = 131072    # E
+    cutoff: float = 10.0       # Å, neighbour-list radius (match the model cutoff)
+
+
+def frame_edges(R: np.ndarray, cutoff: float) -> tuple[np.ndarray, np.ndarray]:
+    """Directed intra-frame pairs (dst, src) with i != j and |r_ij| < cutoff."""
+    d2 = np.sum((R[:, None, :] - R[None, :, :]) ** 2, axis=-1)
+    np.fill_diagonal(d2, np.inf)
+    dst, src = np.nonzero(d2 < cutoff * cutoff)
+    return dst.astype(np.int32), src.astype(np.int32)
+
+
+def _empty_batch(spec: PackSpec) -> dict[str, np.ndarray]:
+    M, A, E = spec.max_molecules, spec.max_atoms, spec.max_edges
+    return {
+        "atomic_numbers": np.zeros((A,), np.int32),
+        "positions": np.zeros((A, 3), np.float32),
+        "forces": np.zeros((A, 3), np.float32),
+        "batch_segments": np.full((A,), M - 1, np.int32),
+        "dst_idx_flat": np.full((E,), A - 1, np.int32),
+        "src_idx_flat": np.full((E,), A - 1, np.int32),
+        "electric_field": np.zeros((M, 3), np.float32),
+        "energies": np.zeros((M,), np.float32),
+        "dipoles": np.zeros((M, 3), np.float32),
+        "polar": np.zeros((M, 3, 3), np.float32),
+        "mol_mask": np.zeros((M,), np.float32),
+        "subset": np.full((M,), -1, np.int32),
+    }
+
+
+def iter_packed_batches(
+    data: Mapping[str, np.ndarray],
+    order: np.ndarray,
+    spec: PackSpec,
+    *,
+    e_ref: np.ndarray | None = None,
+) -> Iterator[dict[str, np.ndarray]]:
+    """Greedily pack frames (in ``order``) into fixed-budget batches.
+
+    ``e_ref`` (indexed by Z, eV) is subtracted from frame energies, so the
+    model learns residual energies instead of absolute ones.
+    """
+    M, A, E = spec.max_molecules, spec.max_atoms, spec.max_edges
+    off = data["offsets"]
+    batch, m, a, e = _empty_batch(spec), 0, 0, 0
+    for f in order:
+        lo, hi = int(off[f]), int(off[f + 1])
+        n = hi - lo
+        R = data["R"][lo:hi]
+        dst, src = frame_edges(R, spec.cutoff)
+        ne = len(dst)
+        if n > A - 1 or ne > E:
+            raise ValueError(f"frame {f} ({n} atoms, {ne} edges) exceeds batch budget {spec}")
+        if m + 1 > M - 1 or a + n > A - 1 or e + ne > E:
+            yield batch
+            batch, m, a, e = _empty_batch(spec), 0, 0, 0
+        Z = data["Z"][lo:hi].astype(np.int32)
+        batch["atomic_numbers"][a:a + n] = Z
+        batch["positions"][a:a + n] = R
+        batch["forces"][a:a + n] = data["F"][lo:hi]
+        batch["batch_segments"][a:a + n] = m
+        batch["dst_idx_flat"][e:e + ne] = dst + a
+        batch["src_idx_flat"][e:e + ne] = src + a
+        energy = float(data["E"][f])
+        if e_ref is not None:
+            energy -= float(e_ref[Z].sum())
+        batch["energies"][m] = energy
+        batch["dipoles"][m] = data["D"][f]
+        batch["polar"][m] = data["polar"][f]
+        batch["mol_mask"][m] = 1.0
+        batch["subset"][m] = int(data["subset"][f])
+        m, a, e = m + 1, a + n, e + ne
+    if m:
+        yield batch
+
+
+def prefetch(it: Iterator, size: int = 8) -> Iterator:
+    """Run a batch iterator in a background thread."""
+    q: queue.Queue = queue.Queue(maxsize=size)
+    sentinel = object()
+
+    def worker():
+        try:
+            for item in it:
+                q.put(item)
+        except BaseException as exc:  # surface errors in the consumer
+            q.put(exc)
+        q.put(sentinel)
+
+    threading.Thread(target=worker, daemon=True).start()
+    while True:
+        item = q.get()
+        if item is sentinel:
+            return
+        if isinstance(item, BaseException):
+            raise item
+        yield item
+
+
+def _forward(model_apply, params, batch, M):
+    (energy, dipole), state = model_apply(
+        params,
+        atomic_numbers=batch["atomic_numbers"],
+        positions=batch["positions"],
+        Ef=batch["electric_field"],
+        dst_idx_flat=batch["dst_idx_flat"],
+        src_idx_flat=batch["src_idx_flat"],
+        batch_segments=batch["batch_segments"],
+        batch_size=M,
+        mutable=["intermediates"],
+    )
+    return energy, dipole, state
+
+
+def _polar(model_apply, params, batch, M, field_scale):
+    return predicted_polarizability_bohr3(
+        model_apply, params, batch["atomic_numbers"], batch["positions"],
+        batch["dst_idx_flat"], batch["src_idx_flat"], batch["batch_segments"], M,
+        field_scale=field_scale,
+    )
+
+
+def packed_losses(model_apply, params, batch, M, weights, field_scale, gradient_checkpoint):
+    """Masked losses (0.5·squared error, as optax.l2_loss elsewhere) and predictions."""
+    mol = batch["mol_mask"]
+    n_mol = jnp.maximum(mol.sum(), 1.0)
+    real = (batch["atomic_numbers"] > 0).astype(jnp.float32)
+    n_atom = jnp.maximum(real.sum(), 1.0)
+
+    def energy_fn(pos):
+        energy, dipole, state = _forward(model_apply, params, {**batch, "positions": pos}, M)
+        return -jnp.sum(energy * mol), (energy, dipole, state)
+
+    if gradient_checkpoint:
+        energy_fn = jax.checkpoint(energy_fn, policy=jax.checkpoint_policies.nothing_saveable)
+    (_, (energy, dipole, state)), forces = jax.value_and_grad(energy_fn, has_aux=True)(batch["positions"])
+    charges = state["intermediates"]["atomic_charges"][-1]  # (A,)
+    q_mol = jax.ops.segment_sum(charges, batch["batch_segments"], num_segments=M)
+
+    terms = {
+        "energy": jnp.sum(0.5 * (energy - batch["energies"]) ** 2 * mol) / n_mol,
+        "forces": jnp.sum(0.5 * (forces - batch["forces"]) ** 2 * real[:, None]) / (3.0 * n_atom),
+        "dipole": jnp.sum(0.5 * (dipole - batch["dipoles"]) ** 2 * mol[:, None]) / (3.0 * n_mol),
+        "charge": jnp.sum(q_mol ** 2 * mol) / n_mol,
+    }
+    polar = jnp.zeros_like(batch["polar"])
+    if weights["polar"] != 0.0:
+        polar = _polar(model_apply, params, batch, M, field_scale)
+        terms["polar"] = jnp.sum(0.5 * (polar - batch["polar"]) ** 2 * mol[:, None, None]) / (9.0 * n_mol)
+    else:
+        terms["polar"] = jnp.asarray(0.0)
+    total = sum(weights[k] * terms[k] for k in terms)
+    preds = {"energy": energy, "forces": forces, "dipole": dipole, "polar": polar}
+    return total, (terms, preds)
+
+
+def make_steps(model_apply, optimizer, M, weights, field_scale, gradient_checkpoint, ema_decay):
+    """jit-compiled (train_step, eval_step) for packed batches."""
+
+    def loss_fn(params, batch):
+        return packed_losses(model_apply, params, batch, M, weights, field_scale, gradient_checkpoint)
+
+    @jax.jit
+    def train_step(params, ema_params, opt_state, batch):
+        (loss, (terms, _)), grads = jax.value_and_grad(loss_fn, has_aux=True)(params, batch)
+        finite = jnp.isfinite(loss)
+        grads = jax.tree_util.tree_map(lambda g: jnp.where(jnp.isfinite(g), g, 0.0), grads)
+        updates, new_opt_state = optimizer.update(grads, opt_state, params)
+        new_params = optax.apply_updates(params, updates)
+        params = jax.tree_util.tree_map(lambda n, o: jnp.where(finite, n, o), new_params, params)
+        opt_state = jax.tree_util.tree_map(lambda n, o: jnp.where(finite, n, o), new_opt_state, opt_state)
+        ema_params = jax.tree_util.tree_map(
+            lambda e, p: jnp.where(finite, ema_decay * e + (1.0 - ema_decay) * p, e), ema_params, params)
+        return params, ema_params, opt_state, loss, terms, finite
+
+    @jax.jit
+    def eval_step(params, batch):
+        loss, (terms, preds) = loss_fn(params, batch)
+        return loss, terms, preds
+
+    return train_step, eval_step
+
+
+class SubsetMetrics:
+    """Accumulates MACE-MDP-style RMSEs per subset (dipole e·Å, polar e·Å²/V)."""
+
+    BOHR3_PER_EA2V = 97.17
+
+    def __init__(self, subset_names: Mapping[int, str]):
+        self.names = dict(subset_names)
+        self.acc: dict[str, dict[str, float]] = {}
+        self._diag = np.eye(3, dtype=bool)
+
+    def _add(self, key, name, sq, count):
+        d = self.acc.setdefault(key, {})
+        d[name + "_sq"] = d.get(name + "_sq", 0.0) + float(sq)
+        d[name + "_n"] = d.get(name + "_n", 0.0) + float(count)
+
+    def update(self, batch, preds):
+        mol = np.asarray(batch["mol_mask"]) > 0
+        sub = np.asarray(batch["subset"])
+        seg = np.asarray(batch["batch_segments"])
+        real = np.asarray(batch["atomic_numbers"]) > 0
+        derr = (np.asarray(preds["dipole"]) - np.asarray(batch["dipoles"]))
+        perr = (np.asarray(preds["polar"]) - np.asarray(batch["polar"])) / self.BOHR3_PER_EA2V
+        eerr = np.asarray(preds["energy"]) - np.asarray(batch["energies"])
+        ferr = np.asarray(preds["forces"]) - np.asarray(batch["forces"])
+        for s in np.unique(sub[mol]):
+            m = mol & (sub == s)
+            for key in ("all", self.names.get(int(s), str(s))):
+                self._add(key, "dipole", np.sum(derr[m] ** 2), 3 * m.sum())
+                self._add(key, "polar_diag", np.sum(perr[m][:, self._diag] ** 2), 3 * m.sum())
+                self._add(key, "polar_offdiag", np.sum(perr[m][:, ~self._diag] ** 2), 6 * m.sum())
+                self._add(key, "energy", np.sum(eerr[m] ** 2), m.sum())
+                atoms = real & m[seg]
+                self._add(key, "forces", np.sum(ferr[atoms] ** 2), 3 * atoms.sum())
+
+    def result(self) -> dict[str, dict[str, float]]:
+        out = {}
+        for key, d in self.acc.items():
+            out[key] = {name: float(np.sqrt(d[name + "_sq"] / max(d[name + "_n"], 1.0)))
+                        for name in ("dipole", "polar_diag", "polar_offdiag", "energy", "forces")}
+            out[key]["n_frames"] = int(d["energy_n"])
+        return out

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/scripts/spice_alpha/convert_full_ragged.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+"""Convert SPICE-α HDF5 files to ragged NPZ shards (one per file).
+
+Usage:
+  python scripts/spice_alpha/convert_full_ragged.py H5_DIR OUT_DIR [--only STEM ...]
+Molecule ids are made unique across files as file_index * 10_000_000 + group index.
+"""
+import argparse
+import json
+from pathlib import Path
+
+from mmml.data.spice_alpha_ragged import SUBSETS, convert_hdf5_ragged
+
+ap = argparse.ArgumentParser()
+ap.add_argument("h5_dir", type=Path)
+ap.add_argument("out_dir", type=Path)
+ap.add_argument("--only", nargs="*", default=None, help="file stems to convert (default: all)")
+args = ap.parse_args()
+args.out_dir.mkdir(parents=True, exist_ok=True)
+for i, stem in enumerate(sorted(SUBSETS)):
+    if args.only and stem not in args.only:
+        continue
+    stats = convert_hdf5_ragged(args.h5_dir / f"{stem}.hdf5", args.out_dir / f"{stem}.npz",
+                                mol_id_base=i * 10_000_000)
+    print(stem, json.dumps(stats), flush=True)

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/scripts/spice_alpha/convert_full_ragged.sbatch

@@ -0,0 +1,17 @@
+#!/bin/bash
+#SBATCH --job-name=ragged-conv
+#SBATCH --partition=scicore
+#SBATCH --qos=6hours
+#SBATCH --time=03:00:00
+#SBATCH --cpus-per-task=2
+#SBATCH --mem=48G
+#SBATCH --array=0-11
+# Convert each SPICE-α HDF5 file to a ragged NPZ shard (one array task per file).
+set -euo pipefail
+REPO="${MMML_REPO:-$HOME/mmml_dev}"
+PY="${MMML_PYTHON:-$HOME/mmml_new/.venv/bin/python}"
+H5_DIR="${H5_DIR:-$HOME/data/spicealpha/SPICE-alpha}"
+OUT_DIR="${OUT_DIR:-$HOME/data/spicealpha/ragged}"
+cd "$REPO"
+mapfile -t STEMS < <(PYTHONPATH="$REPO" "$PY" -c "from mmml.data.spice_alpha_ragged import SUBSETS; print('\n'.join(sorted(SUBSETS)))")
+PYTHONPATH="$REPO" "$PY" scripts/spice_alpha/convert_full_ragged.py "$H5_DIR" "$OUT_DIR" --only "${STEMS[$SLURM_ARRAY_TASK_ID]}"

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/scripts/spice_alpha/eval_polar_dipole.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+"""Dipole and polarizability test errors in the MACE-MDP (Fig. 2) convention.
+
+Reports RMSE of dipole components (e·Å) and of diagonal / off-diagonal
+polarizability elements, in e·Å²/V (MACE-MDP units) and Bohr³. Off-diagonal
+uses the 6 off-diagonal entries of the 3x3 tensor.
+
+Usage (GPU node):
+  python scripts/spice_alpha/eval_polar_dipole.py CKPT_DIR DATA_NPZ [--params params-best.json] [--batch-size 4]
+"""
+
+import argparse
+import functools
+import json
+from pathlib import Path
+
+import numpy as np
+
+BOHR3_PER_EA2V = 97.17  # 1 e·Å²/V = 4πε0-scaled 97.17 Bohr³
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("ckpt_dir", type=Path)
+    ap.add_argument("data_npz", type=Path)
+    ap.add_argument("--params", default="params-best.json")
+    ap.add_argument("--batch-size", type=int, default=4)
+    ap.add_argument("--save-npz", type=Path, default=None, help="write predictions and targets")
+    args = ap.parse_args()
+
+    import e3x
+    import jax
+    import jax.numpy as jnp
+
+    from mmml.models.efield.model_functions import predicted_polarizability_bohr3
+    from mmml.models.efield.training import (
+        MessagePassingModel,
+        load_ef_npz,
+        load_params,
+        prepare_batches,
+    )
+
+    cfg = json.loads((args.ckpt_dir / "config.json").read_text())
+    field_scale = cfg["model"]["field_scale"]
+    model = MessagePassingModel(**cfg["model"])
+    params = load_params(args.ckpt_dir / args.params)
+
+    data = load_ef_npz(args.data_npz)
+    B = args.batch_size
+    n_frames = int(np.asarray(data["electric_field"]).shape[0])
+    n_atoms = int(data["positions"].shape[1])
+    dst, src = e3x.ops.sparse_pairwise_indices(n_atoms)
+    offsets = jnp.arange(B, dtype=jnp.int32) * n_atoms
+    dst_flat = (jnp.asarray(dst, jnp.int32)[None, :] + offsets[:, None]).reshape(-1)
+    src_flat = (jnp.asarray(src, jnp.int32)[None, :] + offsets[:, None]).reshape(-1)
+    seg = jnp.repeat(jnp.arange(B, dtype=jnp.int32), n_atoms)
+    batches = prepare_batches(jax.random.PRNGKey(0), data, B, dst_idx_flat=dst_flat,
+                              src_idx_flat=src_flat, batch_segments=seg, shuffle=False)
+
+    # Training params carry an 'intermediates' collection; rebuild it the same way
+    # evaluate.py does so sow() tracing matches training.
+    b0 = batches[0]
+    _, state = model.apply(params, atomic_numbers=b0["atomic_numbers"], positions=b0["positions"],
+                           Ef=b0["electric_field"], dst_idx_flat=b0["dst_idx_flat"],
+                           src_idx_flat=b0["src_idx_flat"], batch_segments=b0["batch_segments"],
+                           batch_size=B, mutable=["intermediates"])
+    params = {**params, "intermediates": state["intermediates"]}
+
+    @functools.partial(jax.jit)
+    def predict(batch):
+        (_, dipole), _ = model.apply(params, atomic_numbers=batch["atomic_numbers"],
+                                     positions=batch["positions"], Ef=batch["electric_field"],
+                                     dst_idx_flat=batch["dst_idx_flat"], src_idx_flat=batch["src_idx_flat"],
+                                     batch_segments=batch["batch_segments"], batch_size=B,
+                                     mutable=["intermediates"])
+        polar = predicted_polarizability_bohr3(
+            model.apply, params,
+            batch["atomic_numbers"].reshape(B, n_atoms), batch["positions"].reshape(B, n_atoms, 3),
+            batch["dst_idx_flat"], batch["src_idx_flat"], batch["batch_segments"], B,
+            field_scale=field_scale)
+        return dipole, polar
+
+    pd, pa, td, ta = [], [], [], []
+    for batch in batches:
+        dipole, polar = predict(batch)
+        pd.append(np.asarray(dipole)); pa.append(np.asarray(polar))
+        td.append(np.asarray(batch["dipoles"])); ta.append(np.asarray(batch["polar"]))
+    pd, pa, td, ta = (np.concatenate(x) for x in (pd, pa, td, ta))
+
+    diag = np.eye(3, dtype=bool)
+    err = pa - ta
+    rmse = lambda e: float(np.sqrt(np.mean(e ** 2)))
+    res = {
+        "n_frames_evaluated": int(len(pa)), "n_frames_total": n_frames,
+        "dipole_rmse_eA": rmse(pd - td), "dipole_mae_eA": float(np.mean(np.abs(pd - td))),
+        "polar_diag_rmse_bohr3": rmse(err[:, diag]), "polar_offdiag_rmse_bohr3": rmse(err[:, ~diag]),
+        "polar_diag_mae_bohr3": float(np.mean(np.abs(err[:, diag]))),
+        "polar_offdiag_mae_bohr3": float(np.mean(np.abs(err[:, ~diag]))),
+    }
+    for k in [k for k in res if k.endswith("_bohr3")]:
+        res[k.replace("_bohr3", "_eA2V")] = res[k] / BOHR3_PER_EA2V
+    print(json.dumps(res, indent=2))
+    if args.save_npz:
+        np.savez(args.save_npz, dipole_pred=pd, dipole_ref=td, polar_pred_bohr3=pa, polar_ref_bohr3=ta)
+
+
+if __name__ == "__main__":
+    main()

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/scripts/spice_alpha/relative_errors.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python
+"""Validation errors relative to the spread of the validation labels.
+
+Reads efield-train ``history.jsonl`` files and reports, per epoch,
+MAE / MAD(labels) for forces, dipoles and polarizability, plus the polar
+RMSE / sigma. 1.0 means no better than predicting the dataset mean.
+Forces are taken per component over real atoms (Z > 0), in kcal/mol/Å.
+
+Usage:
+  python scripts/spice_alpha/relative_errors.py VALID_NPZ CKPT_DIR [CKPT_DIR ...] [--all]
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+
+EV2KCAL = 23.060548
+
+
+def mad(a: np.ndarray) -> float:
+    return float(np.mean(np.abs(a - a.mean(axis=0))))
+
+
+def label_spread(valid_npz: Path) -> dict:
+    v = np.load(valid_npz)
+    real = v["Z"] > 0
+    polar = v["polar"].reshape(len(v["polar"]), -1)
+    return {
+        "F": mad(v["F"][real] * EV2KCAL),
+        "D": mad(v["D"]),
+        "P": mad(polar),
+        "P_sigma": float(np.std(polar - polar.mean(axis=0))),
+    }
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("valid_npz", type=Path)
+    ap.add_argument("ckpt_dirs", type=Path, nargs="+", help="dirs containing history.jsonl")
+    ap.add_argument("--all", action="store_true", help="print every epoch (default: first 2 + last 3)")
+    args = ap.parse_args()
+
+    s = label_spread(args.valid_npz)
+    print(f"valid label spread: MAD_F={s['F']:.2f} kcal/mol/Å  MAD_D={s['D']:.3f}  "
+          f"MAD_P={s['P']:.2f} Bohr³ (σ_P={s['P_sigma']:.2f})\n")
+    print(f"{'run':32s}{'ep':>4s}{'best':>5s}  {'F/MAD':>6s} {'D/MAD':>6s} {'P/MAD':>6s} {'P rmse/σ':>8s}")
+    for d in args.ckpt_dirs:
+        hist = d / "history.jsonl"
+        if not hist.is_file():
+            print(f"{d.name:32s}  (no history.jsonl yet)")
+            continue
+        rows = [json.loads(line) for line in hist.read_text().splitlines() if line.strip()]
+        if not args.all and len(rows) > 5:
+            rows = rows[:2] + rows[-3:]
+        for h in rows:
+            p = h["valid_polar_mae_bohr3"]
+            # valid_polar_mse is logged as mean(0.5 * diff**2), hence the factor 2 below.
+            # Corrupt polar labels (|alpha| ~ 1e11) make the polar metrics meaningless.
+            ok = p < 1e4
+            prel = f"{p / s['P']:6.3f}" if ok else "   bad"
+            prms = f"{np.sqrt(2 * h['valid_polar_mse_bohr6']) / s['P_sigma']:8.3f}" if ok else "     bad"
+            print(f"{d.name:32s}{h['epoch']:4d}{h['best_epoch']:5d}  "
+                  f"{h['valid_forces_mae_kcal'] / s['F']:6.3f} {h['valid_dipole_mae'] / s['D']:6.3f} {prel} {prms}")
+
+
+if __name__ == "__main__":
+    main()

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/scripts/spice_alpha/subtract_atomic_energies.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+"""Copy an efield splits directory with per-element reference energies removed from E.
+
+SPICE-alpha E labels are absolute total energies (~1e3-1e5 in label units).
+The model's element_bias starts at zero, so it cannot reach those offsets by
+gradient descent. Fit E ~ sum_i e_{Z_i} by least squares on the TRAIN split
+and subtract it from every split; forces are unchanged. The fitted e_Z go to
+atomic_energy_refs.json so predictions can be shifted back.
+
+Usage:
+  python scripts/spice_alpha/subtract_atomic_energies.py SRC_SPLITS DST_SPLITS
+"""
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+
+import numpy as np
+
+
+def composition(Z: np.ndarray, elements: np.ndarray) -> np.ndarray:
+    """(n_frames, n_elements) element counts, ignoring Z=0 padding."""
+    return (Z[:, :, None] == elements[None, None, :]).sum(axis=1).astype(np.float64)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("src", type=Path)
+    ap.add_argument("dst", type=Path)
+    args = ap.parse_args()
+
+    train = np.load(args.src / "energies_forces_dipoles_train.npz")
+    elements = np.unique(train["Z"][train["Z"] > 0])
+    A = composition(train["Z"], elements)
+    e_ref, *_ = np.linalg.lstsq(A, train["E"].astype(np.float64), rcond=None)
+
+    args.dst.mkdir(parents=True, exist_ok=True)
+    report = {"src": str(args.src), "fit_on": "train",
+              "e_ref": {int(z): float(e) for z, e in zip(elements, e_ref)}, "splits": {}}
+    for src in sorted(args.src.glob("*.npz")):
+        data = np.load(src, allow_pickle=False)
+        out = {k: data[k] for k in data.files}
+        unknown = set(np.unique(data["Z"][data["Z"] > 0])) - set(elements.tolist())
+        if unknown:
+            raise SystemExit(f"{src.name}: elements {sorted(unknown)} absent from train fit")
+        resid = data["E"] - composition(data["Z"], elements) @ e_ref
+        out["E"] = resid.astype(data["E"].dtype)
+        np.savez(args.dst / src.name, **out)
+        report["splits"][src.name] = {"E_std_before": float(data["E"].std()),
+                                      "E_std_after": float(resid.std()),
+                                      "E_mad_after": float(np.mean(np.abs(resid - resid.mean())))}
+        print(f"{src.name}: E std {data['E'].std():.4g} -> {resid.std():.4g}")
+    for extra in args.src.glob("*.json"):
+        shutil.copy2(extra, args.dst / extra.name)
+    (args.dst / "atomic_energy_refs.json").write_text(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/scripts/spice_alpha/train_full_packed.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python
+"""Train EFieldPhysNet on full SPICE-α with packed variable-size batches.
+
+Usage:
+  python scripts/spice_alpha/train_full_packed.py RAGGED_DIR OUT_DIR [options]
+
+Writes OUT_DIR/{config.json, split.npz, e_ref.npy, history.jsonl,
+params-last.json, params-best.json, ema-last.json}. Both the latest and the
+best-validation weights are saved every epoch.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+
+
+def parse_args():
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    ap.add_argument("ragged_dir", type=Path)
+    ap.add_argument("out_dir", type=Path)
+    ap.add_argument("--subsets", nargs="*", default=None, help="ragged shard stems (default: all *.npz)")
+    ap.add_argument("--max-train-frames", type=int, default=0, help="subsample train (smoke/benchmark)")
+    ap.add_argument("--max-valid-frames", type=int, default=20000, help="validation subsample per epoch")
+    ap.add_argument("--epochs", type=int, default=10)
+    ap.add_argument("--max-steps", type=int, default=0, help="stop after this many train steps (benchmark)")
+    ap.add_argument("--lr", type=float, default=1e-3)
+    ap.add_argument("--warmup-steps", type=int, default=1000)
+    ap.add_argument("--clip-norm", type=float, default=10.0)
+    ap.add_argument("--ema-decay", type=float, default=0.999)
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--restart", type=Path, default=None, help="params JSON to start from")
+    # packing
+    ap.add_argument("--max-molecules", type=int, default=256)
+    ap.add_argument("--max-atoms", type=int, default=4096)
+    ap.add_argument("--max-edges", type=int, default=131072)
+    # model
+    ap.add_argument("--features", type=int, default=64)
+    ap.add_argument("--max-degree", type=int, default=2)
+    ap.add_argument("--num-iterations", type=int, default=3)
+    ap.add_argument("--num-basis-functions", type=int, default=32)
+    ap.add_argument("--cutoff", type=float, default=6.0)
+    ap.add_argument("--gradient-checkpoint", action="store_true")
+    # loss weights (0.5·squared error per component, as the padded trainer)
+    ap.add_argument("--energy-weight", type=float, default=0.0)
+    ap.add_argument("--forces-weight", type=float, default=1.0)
+    ap.add_argument("--dipole-weight", type=float, default=10.0)
+    ap.add_argument("--polar-weight", type=float, default=1.0)
+    ap.add_argument("--charge-weight", type=float, default=1000.0)
+    ap.add_argument("--log-every", type=int, default=200)
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+    import jax
+    import jax.numpy as jnp
+    import optax
+
+    jax.config.update("jax_enable_x64", False)
+    from mmml.data.spice_alpha_ragged import SUBSET_IDS, fit_atomic_energy_refs, load_ragged, split_ragged, take_frames
+    from mmml.models.efield.packed import PackSpec, SubsetMetrics, iter_packed_batches, make_steps, prefetch
+    from mmml.models.efield.training import EFieldPhysNet, load_params, save_params_json
+
+    out = args.out_dir
+    out.mkdir(parents=True, exist_ok=True)
+    (out / "config.json").write_text(json.dumps({k: str(v) if isinstance(v, Path) else v
+                                                 for k, v in vars(args).items()}, indent=2))
+    shards = sorted(args.ragged_dir.glob("*.npz"))
+    if args.subsets:
+        shards = [p for p in shards if p.stem in args.subsets]
+    t0 = time.time()
+    data = load_ragged(shards)
+    print(f"loaded {len(shards)} shards: {len(data['N'])} frames, {len(data['Z'])} atoms "
+          f"({time.time() - t0:.0f}s)", flush=True)
+
+    split = split_ragged(data, seed=args.seed)
+    np.savez(out / "split.npz", **split)
+    rng = np.random.default_rng(args.seed)
+    train_idx = split["train"]
+    if args.max_train_frames:
+        train_idx = rng.choice(train_idx, size=min(args.max_train_frames, len(train_idx)), replace=False)
+    valid_idx = split["valid"]
+    if args.max_valid_frames and len(valid_idx) > args.max_valid_frames:
+        valid_idx = np.sort(rng.choice(valid_idx, size=args.max_valid_frames, replace=False))
+    print({k: len(v) for k, v in split.items()}, f"train used {len(train_idx)}, valid used {len(valid_idx)}", flush=True)
+
+    e_ref = None
+    if args.energy_weight > 0:
+        e_ref = fit_atomic_energy_refs(take_frames(data, train_idx))
+        np.save(out / "e_ref.npy", e_ref)
+
+    spec = PackSpec(args.max_molecules, args.max_atoms, args.max_edges, args.cutoff)
+    model = EFieldPhysNet(features=args.features, max_degree=args.max_degree,
+                          num_iterations=args.num_iterations, num_basis_functions=args.num_basis_functions,
+                          cutoff=args.cutoff, max_atomic_number=55, include_pseudotensors=True,
+                          field_scale=0.001, zbl=False, electrostatics_damping_sigma=4.0, packed=True)
+    M = spec.max_molecules
+    first = {k: jnp.asarray(v) for k, v in next(iter_packed_batches(data, train_idx[:M], spec)).items()}
+    params = model.init(jax.random.PRNGKey(args.seed), atomic_numbers=first["atomic_numbers"],
+                        positions=first["positions"], Ef=first["electric_field"],
+                        dst_idx_flat=first["dst_idx_flat"], src_idx_flat=first["src_idx_flat"],
+                        batch_segments=first["batch_segments"], batch_size=M)
+    params = {"params": params["params"]}
+    if args.restart:
+        params = {"params": load_params(args.restart)["params"]}
+        print(f"restart from {args.restart}", flush=True)
+    n_params = sum(x.size for x in jax.tree_util.tree_leaves(params))
+    print(f"model params: {n_params}", flush=True)
+
+    steps_per_epoch_est = max(1, int(np.ceil(np.sum(data["N"][train_idx]) / (0.8 * args.max_atoms))))
+    total_steps = args.max_steps or steps_per_epoch_est * args.epochs
+    schedule = optax.warmup_cosine_decay_schedule(0.0, args.lr, min(args.warmup_steps, total_steps // 10 + 1),
+                                                  total_steps, end_value=args.lr * 0.01)
+    optimizer = optax.chain(optax.clip_by_global_norm(args.clip_norm), optax.adam(schedule))
+    opt_state = optimizer.init(params)
+    ema = params
+    weights = {"energy": args.energy_weight, "forces": args.forces_weight, "dipole": args.dipole_weight,
+               "charge": args.charge_weight, "polar": args.polar_weight}
+    train_step, eval_step = make_steps(model.apply, optimizer, M, weights, 0.001,
+                                       args.gradient_checkpoint, args.ema_decay)
+    names = {v: k for k, v in SUBSET_IDS.items()}
+    best = np.inf
+    step = 0
+    hist = (out / "history.jsonl").open("a")
+    for epoch in range(1, args.epochs + 1):
+        order = rng.permutation(train_idx)
+        t_ep, t_log, n_frames, n_atoms, loss_acc, n_acc = time.time(), time.time(), 0, 0, 0.0, 0
+        for batch in prefetch(iter_packed_batches(data, order, spec, e_ref=e_ref)):
+            bj = {k: jnp.asarray(v) for k, v in batch.items()}
+            params, ema, opt_state, loss, terms, finite = train_step(params, ema, opt_state, bj)
+            step += 1
+            n_frames += int(batch["mol_mask"].sum())
+            n_atoms += int((batch["atomic_numbers"] > 0).sum())
+            if step % args.log_every == 0:
+                loss = float(loss)
+                dt = time.time() - t_log
+                print(f"ep {epoch} step {step} loss {loss:.4g} finite {bool(finite)} "
+                      f"{n_frames / (time.time() - t_ep):.0f} frames/s "
+                      f"fill {n_atoms / (step * args.max_atoms) if epoch == 1 else 0:.2f} "
+                      f"terms {{{', '.join(f'{k}: {float(v):.3g}' for k, v in terms.items())}}} "
+                      f"[{dt:.0f}s]", flush=True)
+                t_log = time.time()
+            if args.max_steps and step >= args.max_steps:
+                break
+        train_s = time.time() - t_ep
+        metrics, vloss, vn = SubsetMetrics(names), 0.0, 0
+        for batch in prefetch(iter_packed_batches(data, valid_idx, spec, e_ref=e_ref)):
+            bj = {k: jnp.asarray(v) for k, v in batch.items()}
+            loss, terms, preds = eval_step(ema, bj)
+            vloss += float(loss); vn += 1
+            metrics.update(batch, jax.device_get(preds))
+        vloss /= max(vn, 1)
+        res = metrics.result()
+        save_params_json(out / "params-last.json", params)
+        save_params_json(out / "ema-last.json", ema)
+        improved = vloss < best
+        if improved:
+            best = vloss
+            save_params_json(out / "params-best.json", ema)
+        rec = {"epoch": epoch, "step": step, "train_s": train_s, "frames_per_s": n_frames / max(train_s, 1e-9),
+               "valid_loss": vloss, "improved": improved, "lr": float(schedule(step)), "valid": res}
+        hist.write(json.dumps(rec) + "\n"); hist.flush()
+        a = res.get("all", {})
+        print(f"== epoch {epoch} train {train_s:.0f}s valid_loss {vloss:.4g} "
+              f"dipole {a.get('dipole', np.nan):.4f} eÅ polar diag {a.get('polar_diag', np.nan):.4f} "
+              f"offdiag {a.get('polar_offdiag', np.nan):.4f} eŲ/V forces {a.get('forces', np.nan):.3f} eV/Š"
+              f"{'*' if improved else ''}", flush=True)
+        if args.max_steps and step >= args.max_steps:
+            break
+
+
+if __name__ == "__main__":
+    main()

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/scripts/spice_alpha/train_full_packed.sbatch

@@ -0,0 +1,24 @@
+#!/bin/bash
+#SBATCH --job-name=spicea-full
+#SBATCH --partition=h200
+#SBATCH --qos=h200-1day
+#SBATCH --time=1-00:00:00
+#SBATCH --gres=gpu:1
+#SBATCH --cpus-per-task=8
+#SBATCH --mem=96G
+#SBATCH --output=logs/spicea_full_%j.out
+# Full SPICE-α packed training on one H200. Options pass through to the driver:
+#   sbatch scripts/spice_alpha/train_full_packed.sbatch OUT_DIR [--epochs 20 ...]
+set -euo pipefail
+REPO="${MMML_REPO:-$HOME/mmml_dev}"
+PY="${MMML_PYTHON:-$HOME/mmml_new/.venv/bin/python}"
+RAGGED="${RAGGED:-$HOME/data/spicealpha/ragged}"
+cd "$REPO"
+export PYTHONPATH="$REPO" PYTHONUNBUFFERED=1 JAX_ENABLE_X64=0
+export XLA_PYTHON_CLIENT_PREALLOCATE=false XLA_PYTHON_CLIENT_MEM_FRACTION=0.9
+export XLA_FLAGS="${XLA_FLAGS:---xla_gpu_autotune_level=0}"
+OUT="$1"; shift
+mkdir -p "$OUT"
+nvidia-smi --query-gpu=timestamp,name,memory.used,utilization.gpu --format=csv,noheader -l 30 > "$OUT/gpu_usage.csv" &
+trap 'kill $! 2>/dev/null || true' EXIT
+"$PY" scripts/spice_alpha/train_full_packed.py "$RAGGED" "$OUT" "$@"

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/tests/unit/test_efield_packed.py

@@ -0,0 +1,123 @@
+"""Packed variable-size batches must reproduce the fixed-size padded path."""
+
+from __future__ import annotations
+
+import jax
+import jax.numpy as jnp
+import numpy as np
+import optax
+import pytest
+
+from mmml.data.spice_alpha_ragged import offsets_from_counts, split_ragged
+from mmml.models.efield.model_functions import predicted_polarizability_bohr3
+from mmml.models.efield.packed import PackSpec, iter_packed_batches, make_steps, SubsetMetrics
+from mmml.models.efield.training import EFieldPhysNet, energy_and_forces, load_ef_npz, prepare_batches
+
+from test_spice_alpha_efield_train import _init_params, _spice_efield_splits, _tiny_model
+
+
+@pytest.fixture(scope="module", autouse=True)
+def _float32():
+    prev = bool(jax.config.jax_enable_x64)
+    jax.config.update("jax_enable_x64", False)
+    yield
+    jax.config.update("jax_enable_x64", prev)
+
+
+def _packed_model() -> EFieldPhysNet:
+    return _tiny_model().clone(packed=True)
+
+
+def _ragged_from_padded(d: dict) -> dict:
+    Z = np.asarray(d["atomic_numbers"])
+    keep = Z > 0
+    N = keep.sum(axis=1).astype(np.int16)
+    n = len(N)
+    return {
+        "Z": Z[keep].astype(np.int8),
+        "R": np.asarray(d["positions"])[keep],
+        "F": np.asarray(d["forces"])[keep],
+        "N": N,
+        "E": np.asarray(d["energies"], np.float64),
+        "D": np.asarray(d["D"]),
+        "Q": np.zeros((n,), np.float32),
+        "polar": np.asarray(d["polar"]),
+        "mol": np.arange(n),
+        "subset": np.zeros((n,), np.int8),
+        "offsets": offsets_from_counts(N),
+    }
+
+
+def test_packed_matches_padded(tmp_path):
+    written = _spice_efield_splits(tmp_path, n_confs=8)
+    train = load_ef_npz(written["train"])
+    padded_model, packed_model = _tiny_model(), _packed_model()
+    params = _init_params(padded_model, train, jax.random.PRNGKey(5))
+    B = 2
+    pb = prepare_batches(jax.random.PRNGKey(0), train, B, shuffle=False, rot_augment=False)[0]
+    n_atoms = pb["positions"].shape[0] // B
+
+    e_pad, f_pad, d_pad = energy_and_forces(
+        padded_model.apply, params, pb["atomic_numbers"], pb["positions"], pb["electric_field"],
+        pb["dst_idx_flat"], pb["src_idx_flat"], pb["batch_segments"], B)
+    a_pad = predicted_polarizability_bohr3(
+        padded_model.apply, params, pb["atomic_numbers"].reshape(B, n_atoms),
+        pb["positions"].reshape(B, n_atoms, 3), pb["dst_idx_flat"], pb["src_idx_flat"],
+        pb["batch_segments"], B)
+
+    ragged = _ragged_from_padded(train)
+    spec = PackSpec(max_molecules=B + 1, max_atoms=3 * n_atoms + 1, max_edges=4096, cutoff=5.0)
+    batch = next(iter_packed_batches(ragged, np.arange(B), spec))
+    M = spec.max_molecules
+    bj = {k: jnp.asarray(v) for k, v in batch.items()}
+    e_pk, f_pk, d_pk = energy_and_forces(
+        packed_model.apply, params, bj["atomic_numbers"], bj["positions"], bj["electric_field"],
+        bj["dst_idx_flat"], bj["src_idx_flat"], bj["batch_segments"], M)
+    a_pk = predicted_polarizability_bohr3(
+        packed_model.apply, params, bj["atomic_numbers"], bj["positions"], bj["dst_idx_flat"],
+        bj["src_idx_flat"], bj["batch_segments"], M)
+
+    np.testing.assert_allclose(np.asarray(e_pk)[:B], np.asarray(e_pad), rtol=1e-5, atol=1e-4)
+    np.testing.assert_allclose(np.asarray(d_pk)[:B], np.asarray(d_pad), rtol=1e-5, atol=1e-5)
+    np.testing.assert_allclose(np.asarray(a_pk)[:B], np.asarray(a_pad), rtol=1e-4, atol=1e-4)
+    real_pad = np.asarray(pb["atomic_numbers"]) > 0
+    real_pk = np.asarray(bj["atomic_numbers"]) > 0
+    np.testing.assert_allclose(np.asarray(f_pk)[real_pk], np.asarray(f_pad)[real_pad], rtol=1e-4, atol=1e-5)
+    # The padding molecule slot gets nothing.
+    assert float(np.abs(np.asarray(d_pk)[M - 1]).max()) == 0.0
+
+
+def test_packed_train_step_moves_params_and_masks_padding(tmp_path):
+    written = _spice_efield_splits(tmp_path, n_confs=8)
+    train = load_ef_npz(written["train"])
+    model = _packed_model()
+    params = _init_params(_tiny_model(), train, jax.random.PRNGKey(6))
+    ragged = _ragged_from_padded(train)
+    spec = PackSpec(max_molecules=4, max_atoms=16, max_edges=512, cutoff=5.0)
+    batches = list(iter_packed_batches(ragged, np.arange(len(ragged["N"])), spec))
+    assert len(batches) >= 2  # budget forces several batches
+    weights = {"energy": 0.0, "forces": 1.0, "dipole": 1.0, "charge": 1.0, "polar": 1.0}
+    opt = optax.adam(1e-2)
+    train_step, eval_step = make_steps(model.apply, opt, spec.max_molecules, weights, 0.001, False, 0.5)
+    b = {k: jnp.asarray(v) for k, v in batches[0].items()}
+    new_params, ema, _, loss, terms, finite = train_step(params, params, opt.init(params), b)
+    assert bool(finite) and np.isfinite(float(loss))
+    delta = max(float(jnp.max(jnp.abs(x - y))) for x, y in
+                zip(jax.tree_util.tree_leaves(new_params), jax.tree_util.tree_leaves(params)))
+    assert delta > 0.0
+    loss_e, terms_e, preds = eval_step(new_params, b)
+    metrics = SubsetMetrics({0: "water"})
+    metrics.update(batches[0], jax.device_get(preds))
+    res = metrics.result()
+    assert res["water"]["n_frames"] == int(batches[0]["mol_mask"].sum())
+    assert all(np.isfinite(v) for v in res["all"].values())
+
+
+def test_split_ragged_holds_out_whole_molecules():
+    n_mol, per = 200, 5
+    mol = np.repeat(np.arange(n_mol), per)
+    data = {"subset": np.zeros(len(mol), np.int8), "mol": mol}
+    idx = split_ragged(data, valid_frac=0.1, test_frac=0.1, seed=1)
+    sets = {k: set(mol[v]) for k, v in idx.items()}
+    assert not (sets["train"] & sets["valid"]) and not (sets["train"] & sets["test"])
+    assert sum(len(v) for v in idx.values()) == len(mol)

synced/mmml_new_ckpts/spicea_full_v1_q10/code_snapshot/tracked.diff

@@ -0,0 +1,349 @@
+diff --git a/mmml/models/efield/model_functions.py b/mmml/models/efield/model_functions.py
+index b7ccad408..08b163fb5 100644
+--- a/mmml/models/efield/model_functions.py
++++ b/mmml/models/efield/model_functions.py
+@@ -181,7 +181,7 @@ def dipole_derivative_field(
+ def dipole_derivative_field_batched(
+     model_apply, params, atomic_numbers, positions, Ef,
+     dst_idx_flat, src_idx_flat, batch_segments, batch_size,
+-    dst_idx=None, src_idx=None,
++    dst_idx=None, src_idx=None, mode="fwd",
+ ):
+     """Batched polarizability:  alpha_ab = d(mu_a)/d(Ef_b) for B geometries.
+ 
+@@ -218,7 +218,14 @@ def dipole_derivative_field_batched(
+         )
+         return dipole  # (B, 3)
+ 
+-    return jax.jacrev(dipole_fn)(Ef)  # (B, 3, 3)
++    # The input is the 3-vector Ef but the output is (B, 3), so forward mode
++    # needs 3 JVPs while reverse mode needs 3*B VJPs; jacrev's cost and memory
++    # grow ~B^2 (B=16 asked XLA for ~56 GB on a 24 GB card).
++    if mode == "fwd":
++        return jax.jacfwd(dipole_fn)(Ef)  # (B, 3, 3)
++    if mode == "rev":
++        return jax.jacrev(dipole_fn)(Ef)  # (B, 3, 3)
++    raise ValueError(f"mode must be 'fwd' or 'rev', got {mode!r}")
+ 
+ 
+ def predicted_polarizability_bohr3(
+@@ -233,6 +240,7 @@ def predicted_polarizability_bohr3(
+     *,
+     field_scale: float = 0.001,
+     ef_shared=None,
++    mode: str = "fwd",
+ ):
+     """Physical polarizability in Bohr³ from ``dμ/dEf`` at a shared field.
+ 
+@@ -257,6 +265,7 @@ def predicted_polarizability_bohr3(
+         src_idx_flat,
+         batch_segments,
+         batch_size,
++        mode=mode,
+     )
+     scale = jnp.asarray(field_scale, dtype=alpha_raw.dtype)
+     return alpha_raw / scale * jnp.asarray(ANGSTROM_TO_BOHR, dtype=alpha_raw.dtype)
+diff --git a/mmml/models/efield/training.py b/mmml/models/efield/training.py
+index df6f01783..50c457ddb 100644
+--- a/mmml/models/efield/training.py
++++ b/mmml/models/efield/training.py
+@@ -248,6 +248,11 @@ class EFieldPhysNet(nn.Module):
+     # ZBL: Ziegler-Biersack-Littmark nuclear repulsion for short-range stability
+     zbl: bool = False
+     electrostatics_damping_sigma: float = 4.0
++    # packed=True: atoms of B molecules are concatenated with variable counts
++    # (batch_segments gives each atom's molecule slot); per-molecule sums use
++    # segment ops and the 'atomic_charges'/'atomic_dipoles' intermediates are
++    # flat (A,) / (A, 3) instead of (B, N) / (B, N, 3).
++    packed: bool = False
+ 
+     def setup(self):
+         if self.zbl:
+@@ -275,7 +280,8 @@ class EFieldPhysNet(nn.Module):
+         atomic_numbers_flat = atomic_numbers.reshape(-1)  # Ensure (B*N,) - 1D array
+                 # Basic dims: use static values (CUDA-graph-friendly)
+         B = batch_size  # Static - known at compile time
+-        N = atomic_numbers_flat.shape[0] // B   # Static - constant number of atoms per molecule
++        A = atomic_numbers_flat.shape[0]  # total (padded) atoms in the batch
++        N = A // B   # atoms per molecule; only meaningful when not packed
+         # Compute displacements using e3x gather operations (CUDA-graph-friendly)
+         # Must use flattened indices to get (B*E, 3) displacements matching MessagePass
+         positions_dst = e3x.ops.gather_dst(positions_flat, dst_idx=dst_idx_flat)
+@@ -301,12 +307,10 @@ class EFieldPhysNet(nn.Module):
+         xEF = jnp.tile(xEF, (1, 1, 1, self.features)) # (B, 1, 4, features)
+         # Expand to per-atom level: (B, 1, 4, features) -> (B, N, 1, 4, features) -> (B*N, 1, 4, features)
+         # Insert dimension for N, then repeat: (B, 1, 4, features) -> (B, 1, 1, 4, features) -> (B, N, 1, 4, features)
+-        xEF = xEF[:, None, :, :]  # (B, 1, 1, 4, features) - add dimension
+-        xEF = jnp.repeat(xEF, N, axis=1)  # (B, N, 1, 4, features) - repeat N times
+-        xEF = xEF.reshape(B * N, 1, 4, self.features)  # (B*N, 1, 4, features)
++        xEF = xEF[batch_segments]  # (A, 1, 4, features) - each atom gets its molecule's field
+         # Broadcast parity dim to match x (1 if no pseudotensors, 2 if include_pseudotensors)
+         parity_dim = 2 if self.include_pseudotensors else 1
+-        xEF = jnp.broadcast_to(xEF, (B * N, parity_dim, 4, self.features))
++        xEF = jnp.broadcast_to(xEF, (A, parity_dim, 4, self.features))
+ 
+ 
+         xEF = e3x.nn.change_max_degree_or_type(xEF, max_degree=self.max_degree,
+@@ -371,35 +375,32 @@ class EFieldPhysNet(nn.Module):
+             # Shape: (B*N, parity, 3, 1) -> take parity=0 (real part) -> (B*N, 3, 1) -> squeeze -> (B*N, 3)
+             atomic_dipoles = x_dipole[:, 0, 1:4, 0]  # (B*N, 3) - take first parity (real), l=1 components, squeeze features
+             atomic_dipoles = atomic_dipoles * real_atom[:, None]
+-            dipoles_batched = atomic_dipoles.reshape(B, N, 3)  # (B, N, 3)
+         else:
+-            dipoles_batched = jnp.zeros((B, N, 3))
++            atomic_dipoles = jnp.zeros((A, 3), dtype=positions_flat.dtype)
+ 
+ 
+ 
+         # Compute molecular dipole: μ = Σ(q_i * (r_i - COM)) + Σ(μ_i)
+-        # Reshape to (B, N, 3) for positions and dipoles, (B, N) for charges
+-        positions_batched = positions_flat.reshape(B, N, 3)  # (B, N, 3)
+-        charges_batched = atomic_charges.reshape(B, N)  # (B, N)
+-
+-        # Center of mass (using atomic masses or uniform weighting)
+-        # For simplicity, use uniform weighting (geometric center)
+-        # (real atoms only; padding sits at the origin)
+-        real_batched = real_atom.reshape(B, N, 1)
+-        com = jnp.sum(positions_batched * real_batched, axis=1, keepdims=True) / jnp.maximum(
+-            jnp.sum(real_batched, axis=1, keepdims=True), 1.0
+-        )  # (B, 1, 3)
+-        positions_centered = positions_batched - com  # (B, N, 3)
+-        # Charge contribution: Σ(q_i * (r_i - COM))
+-        charge_dipole = jnp.sum(charges_batched[:, :, None] * positions_centered, axis=1)  # (B, 3)
+-        # Atomic dipole contribution: Σ(μ_i)
+-        atomic_dipole_sum = jnp.sum(dipoles_batched, axis=1)  # (B, 3)
+-        # Total molecular dipole
++        # Per-molecule sums run over batch_segments, so the same code serves
++        # fixed-size padded batches and packed variable-size batches.
++        def mol_sum(v):
++            return jax.ops.segment_sum(v, batch_segments, num_segments=B)
++
++        # Geometric center of the real atoms (padding sits at the origin)
++        n_real = jnp.maximum(mol_sum(real_atom), 1.0)  # (B,)
++        com = mol_sum(positions_flat * real_atom[:, None]) / n_real[:, None]  # (B, 3)
++        positions_centered = positions_flat - com[batch_segments]  # (A, 3)
++        charge_dipole = mol_sum(atomic_charges[:, None] * positions_centered)  # (B, 3)
++        atomic_dipole_sum = mol_sum(atomic_dipoles)  # (B, 3)
+         dipole = charge_dipole + atomic_dipole_sum  # (B, 3)
+ 
+-        # Store atomic-level properties for downstream use (e.g. AAT)
+-        self.sow('intermediates', 'atomic_charges', charges_batched)      # (B, N)
+-        self.sow('intermediates', 'atomic_dipoles', dipoles_batched)      # (B, N, 3)
++        # Store atomic-level properties for downstream use (e.g. AAT, charge loss)
++        if self.packed:
++            self.sow('intermediates', 'atomic_charges', atomic_charges)   # (A,)
++            self.sow('intermediates', 'atomic_dipoles', atomic_dipoles)   # (A, 3)
++        else:
++            self.sow('intermediates', 'atomic_charges', atomic_charges.reshape(B, N))      # (B, N)
++            self.sow('intermediates', 'atomic_dipoles', atomic_dipoles.reshape(B, N, 3))   # (B, N, 3)
+ 
+         # Predict atomic energies (reduce to scalar per atom like x_charge)
+         x_energy = e3x.nn.change_max_degree_or_type(x, max_degree=0, include_pseudotensors=False)  # (B*N, 1, 1, features)
+@@ -416,7 +417,7 @@ class EFieldPhysNet(nn.Module):
+         if self.zbl:
+             distances = jnp.linalg.norm(safe_displacements, axis=-1)  # (B*E,)
+             distances = jnp.maximum(distances, 1e-8)
+-            atom_mask = jnp.ones(B * N, dtype=positions_flat.dtype)
++            atom_mask = jnp.ones(A, dtype=positions_flat.dtype)
+             batch_mask = jnp.ones_like(distances, dtype=positions_flat.dtype)
+             repulsion = self.repulsion(
+                 atomic_numbers_flat,
+@@ -436,7 +437,7 @@ class EFieldPhysNet(nn.Module):
+         # Omit padding / inactive sites (Z<=0) from the total — same as ASE on
+         # real atoms only; padded batches would otherwise double-count NN heads.
+         valid_atom = (atomic_numbers_flat > 0).astype(atomic_energies.dtype)
+-        energy = (atomic_energies * valid_atom).reshape(B, N).sum(axis=1)  # (B,)
++        energy = mol_sum(atomic_energies * valid_atom)  # (B,)
+ 
+         # E_coul = (1/2) Σ q_i q_j / r_ij in Hartree with r_ij in Bohr; positions here are Å.
+         r_ij_angstrom = jnp.linalg.norm(safe_displacements, axis=-1)  # (B*E,)
+diff --git a/scripts/spice_alpha/train_efield_polar.sbatch b/scripts/spice_alpha/train_efield_polar.sbatch
+index 6ab17937e..e8d90e490 100755
+--- a/scripts/spice_alpha/train_efield_polar.sbatch
++++ b/scripts/spice_alpha/train_efield_polar.sbatch
+@@ -81,6 +81,44 @@ else
+   export MAX_DEGREE="${MAX_DEGREE:-1}"
+ fi
+ 
++# Some sciCORE nodes (seen on sgd01) expose every GPU to every job while still
++# setting CUDA_VISIBLE_DEVICES=0, so concurrent jobs pile onto one card. If the
++# visible device 0 is already busy, move to the least-used visible GPU.
++if command -v nvidia-smi >/dev/null 2>&1; then
++  n_visible="$(nvidia-smi -L | wc -l)"
++  if [[ "$n_visible" -gt 1 ]]; then
++    # Pick under a per-node lock and record the claim, so jobs that start at
++    # the same moment (before either has allocated memory) cannot pick the same card.
++    claim_dir="$HOME/.cache/gpu_guard/$(hostname)"; mkdir -p "$claim_dir"
++    exec 9>"$claim_dir/.lock"; flock 9
++    for f in "$claim_dir"/*.claim; do
++      [[ -e "$f" ]] || continue
++      squeue -h -j "$(basename "$f" .claim)" -t R 2>/dev/null | grep -q . || rm -f "$f"
++    done
++    claimed="$(cat "$claim_dir"/*.claim 2>/dev/null | sort -u || true)"
++    pick=""
++    while IFS=, read -r idx uuid used; do
++      uuid="${uuid// /}"; used="${used// /}"
++      grep -qx "$uuid" <<<"$claimed" && continue
++      [[ "$used" -gt 1000 ]] && continue
++      pick="$idx"; pick_uuid="$uuid"; break
++    done < <(nvidia-smi --query-gpu=index,uuid,memory.used --format=csv,noheader,nounits)
++    if [[ -n "$pick" ]]; then
++      [[ "$pick" != "${CUDA_VISIBLE_DEVICES:-0}" ]] && echo "GPU guard: using GPU $pick ($pick_uuid; ${n_visible} visible)" >&2
++      export CUDA_VISIBLE_DEVICES="$pick"
++      echo "$pick_uuid" > "$claim_dir/${SLURM_JOB_ID}.claim"
++    else
++      echo "GPU guard: no unclaimed idle GPU among ${n_visible}; keeping ${CUDA_VISIBLE_DEVICES:-0}" >&2
++    fi
++    flock -u 9; exec 9>&-
++  fi
++  mkdir -p "$CKPT"
++  nvidia-smi -i "${CUDA_VISIBLE_DEVICES:-0}" --query-gpu=timestamp,uuid,memory.used,utilization.gpu \
++    --format=csv,noheader -l 30 > "$CKPT/gpu_usage.csv" 2>/dev/null &
++  GPU_LOGGER_PID=$!
++  trap 'kill "$GPU_LOGGER_PID" 2>/dev/null || true; rm -f "$HOME/.cache/gpu_guard/$(hostname)/${SLURM_JOB_ID}.claim"' EXIT
++fi
++
+ echo "efield-train mode=$MODE epochs=$EPOCHS B=$BATCH_SIZE F=$FEATURES L=$MAX_DEGREE T=${NUM_ITERATIONS:-2} nbasis=${NUM_BASIS_FUNCTIONS:-10} rc=${CUTOFF:-10} polar_w=${POLAR_WEIGHT:-1}"
+ 
+ "$ROOT/scripts/spice_alpha/train_efield_polar.sh" "$SPLITS" "$CKPT" "$EPOCHS"
+diff --git a/scripts/spice_alpha/train_efield_polar.sh b/scripts/spice_alpha/train_efield_polar.sh
+index 890300a3b..2d8f5d555 100755
+--- a/scripts/spice_alpha/train_efield_polar.sh
++++ b/scripts/spice_alpha/train_efield_polar.sh
+@@ -56,6 +56,9 @@ fi
+ if [[ -n "${SAVE_EVERY:-}" ]]; then
+   EXTRA+=(--save-every "$SAVE_EVERY")
+ fi
++if [[ -n "${LEARNING_RATE:-}" ]]; then
++  EXTRA+=(--learning_rate "$LEARNING_RATE")
++fi
+ if [[ -n "${RESTART:-}" ]]; then
+   EXTRA+=(--restart "$RESTART")
+ fi
+diff --git a/tests/unit/test_spice_alpha_efield_train.py b/tests/unit/test_spice_alpha_efield_train.py
+index bc675eca5..0f9deec74 100644
+--- a/tests/unit/test_spice_alpha_efield_train.py
++++ b/tests/unit/test_spice_alpha_efield_train.py
+@@ -264,6 +264,79 @@ def test_spice_alpha_efield_train_step_polar_finite(tmp_path):
+     assert np.isfinite(float(eval_polar_mae))
+ 
+ 
++def test_spice_alpha_efield_train_step_padded_atoms_finite(tmp_path):
++    """Z=0 padding atoms share the origin, so pad-pad pairs have r_ij = 0.
++    The Coulomb norm's gradient there was NaN, which made every padded batch's
++    force loss NaN and train_step skip the update (loss reported as 1e6)."""
++    written = _spice_efield_splits(tmp_path)
++    train = load_ef_npz(written["train"])
++    n_pad = 2
++    n = train["positions"].shape[0]
++    train["atomic_numbers"] = jnp.concatenate(
++        [train["atomic_numbers"], jnp.zeros((n, n_pad), dtype=jnp.int32)], axis=1
++    )
++    zeros = jnp.zeros((n, n_pad, 3), dtype=jnp.float32)
++    train["positions"] = jnp.concatenate([train["positions"], zeros], axis=1)
++    train["forces"] = jnp.concatenate([train["forces"], zeros], axis=1)
++
++    model = _tiny_model()
++    params = _init_params(model, train, jax.random.PRNGKey(1))
++    optimizer = optax.adam(1e-3)
++    transform_state = optax.contrib.reduce_on_plateau().init(params)
++    batch = prepare_batches(
++        jax.random.PRNGKey(2),
++        train,
++        batch_size=BATCH_SIZE,
++        shuffle=False,
++        rot_augment=False,
++    )[0]
++    out = train_step(
++        model_apply=model.apply,
++        optimizer_update=optimizer.update,
++        batch=batch,
++        batch_size=BATCH_SIZE,
++        opt_state=optimizer.init(params),
++        params=params,
++        ema_params=params,
++        transform_state=transform_state,
++        ema_decay=0.5,
++        forces_weight=1.0,
++        polar_weight=1.0,
++    )
++    new_params, _ema, _opt, loss = out[:4]
++    force_loss = out[12]
++    assert np.isfinite(float(force_loss))
++    assert float(loss) != 1e6
++    assert _max_abs_delta(new_params, params) > 0.0
++
++    # Padding must be invisible: same energy and dipole as the unpadded batch.
++    unpadded = load_ef_npz(written["train"])
++    plain = prepare_batches(
++        jax.random.PRNGKey(2),
++        unpadded,
++        batch_size=BATCH_SIZE,
++        shuffle=False,
++        rot_augment=False,
++    )[0]
++
++    def _apply(b):
++        return model.apply(
++            new_params,
++            atomic_numbers=b["atomic_numbers"],
++            positions=b["positions"],
++            Ef=b["electric_field"],
++            dst_idx_flat=b["dst_idx_flat"],
++            src_idx_flat=b["src_idx_flat"],
++            batch_segments=b["batch_segments"],
++            batch_size=BATCH_SIZE,
++        )
++
++    e_pad, mu_pad = _apply(batch)
++    e_plain, mu_plain = _apply(plain)
++    np.testing.assert_allclose(np.asarray(e_pad), np.asarray(e_plain), rtol=1e-5, atol=1e-5)
++    np.testing.assert_allclose(np.asarray(mu_pad), np.asarray(mu_plain), rtol=1e-5, atol=1e-5)
++
++
+ def test_spice_alpha_efield_train_model_one_epoch(tmp_path, capsys):
+     written = _spice_efield_splits(tmp_path)
+     train = load_ef_npz(written["train"])
+@@ -295,3 +368,42 @@ def test_spice_alpha_efield_train_model_one_epoch(tmp_path, capsys):
+     logged = capsys.readouterr().out
+     assert "polar mae" in logged
+     assert "polar MSE" in logged
++
++
++def test_polarizability_jacfwd_matches_jacrev(tmp_path):
++    """Forward-mode dμ/dEf (3 JVPs) must equal the old reverse-mode result
++    (3·B VJPs), both for α itself and for the parameter gradient of the loss."""
++    from mmml.models.efield.model_functions import predicted_polarizability_bohr3
++
++    written = _spice_efield_splits(tmp_path)
++    train = load_ef_npz(written["train"])
++    model = _tiny_model()
++    params = _init_params(model, train, jax.random.PRNGKey(3))
++    batch = prepare_batches(
++        jax.random.PRNGKey(4), train, batch_size=BATCH_SIZE, shuffle=False, rot_augment=False
++    )[0]
++    n_atoms = batch["positions"].shape[0] // BATCH_SIZE
++
++    def alpha(params_, mode):
++        return predicted_polarizability_bohr3(
++            model.apply,
++            params_,
++            batch["atomic_numbers"].reshape(BATCH_SIZE, n_atoms),
++            batch["positions"].reshape(BATCH_SIZE, n_atoms, 3),
++            batch["dst_idx_flat"],
++            batch["src_idx_flat"],
++            batch["batch_segments"],
++            BATCH_SIZE,
++            field_scale=0.001,
++            mode=mode,
++        )
++
++    fwd, rev = alpha(params, "fwd"), alpha(params, "rev")
++    assert fwd.shape == (BATCH_SIZE, 3, 3)
++    np.testing.assert_allclose(np.asarray(fwd), np.asarray(rev), rtol=1e-4, atol=1e-5)
++
++    target = jnp.asarray(batch["polar"])
++    g_fwd = jax.grad(lambda p: jnp.mean((alpha(p, "fwd") - target) ** 2))(params)
++    g_rev = jax.grad(lambda p: jnp.mean((alpha(p, "rev") - target) ** 2))(params)
++    for a, b in zip(jax.tree_util.tree_leaves(g_fwd), jax.tree_util.tree_leaves(g_rev)):
++        np.testing.assert_allclose(np.asarray(a), np.asarray(b), rtol=1e-3, atol=1e-6)

synced/mmml_new_ckpts/spicea_full_v1_q10/config.json

@@ -0,0 +1,30 @@
+{
+  "ragged_dir": "/scicore/home/meuwly/boitti0000/data/spicealpha/ragged",
+  "out_dir": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10",
+  "subsets": null,
+  "max_train_frames": 0,
+  "max_valid_frames": 20000,
+  "epochs": 60,
+  "max_steps": 0,
+  "lr": 0.001,
+  "warmup_steps": 1000,
+  "clip_norm": 10.0,
+  "ema_decay": 0.999,
+  "seed": 0,
+  "restart": null,
+  "max_molecules": 256,
+  "max_atoms": 4096,
+  "max_edges": 98304,
+  "features": 64,
+  "max_degree": 2,
+  "num_iterations": 3,
+  "num_basis_functions": 32,
+  "cutoff": 5.0,
+  "gradient_checkpoint": false,
+  "energy_weight": 0.0,
+  "forces_weight": 10.0,
+  "dipole_weight": 10.0,
+  "polar_weight": 10.0,
+  "charge_weight": 10.0,
+  "log_every": 500
+}

synced/mmml_new_ckpts/spicea_full_v1_q10/history.jsonl

@@ -0,0 +1,40 @@
+{"epoch": 1, "step": 13105, "train_s": 5924.272532939911, "frames_per_s": 252.33646691438642, "valid_loss": 78.64648012731267, "improved": true, "lr": 0.000999624957330525, "valid": {"all": {"dipole": 0.4188497869345922, "polar_diag": 0.047900909902022726, "polar_offdiag": 0.029891233527042222, "energy": 54502.26555385014, "forces": 0.7127457932080548, "n_frames": 20000}, "dimers": {"dipole": 0.2553239700332011, "polar_diag": 0.015817676133575063, "polar_offdiag": 0.010414545452482998, "energy": 24680.555296872215, "forces": 0.4947426853147928, "n_frames": 3823}, "monomers": {"dipole": 0.16940939126507515, "polar_diag": 0.014352835745436898, "polar_offdiag": 0.009985092538131513, "energy": 18201.99562894658, "forces": 0.6421258614594092, "n_frames": 210}, "pubchem": {"dipole": 0.42048081429031575, "polar_diag": 0.053664520150134135, "polar_offdiag": 0.032745923351729884, "energy": 59326.03417329921, "forces": 0.7687908836175121, "n_frames": 13745}, "solvated_pubchem": {"dipole": 1.2434318194144858, "polar_diag": 0.1159662985437062, "polar_offdiag": 0.08174947813818396, "energy": 139659.87173679654, "forces": 0.7035610774027773, "n_frames": 156}, "water": {"dipole": 1.23991973970989, "polar_diag": 0.04181402095704398, "polar_offdiag": 0.026480646347184462, "energy": 62412.53676259969, "forces": 0.9141579166538994, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.519744822388546, "polar_diag": 0.04144997041204011, "polar_offdiag": 0.029778853152613874, "energy": 54237.86905421311, "forces": 0.4768808769470988, "n_frames": 1799}, "dipeptides": {"dipole": 0.5029635516202048, "polar_diag": 0.018500588257784886, "polar_offdiag": 0.012811111285058914, "energy": 29781.72763125136, "forces": 0.671393322639381, "n_frames": 245}, "solvated_amino_acid": {"dipole": 1.2482874859079942, "polar_diag": 0.03771632239855658, "polar_offdiag": 0.028802502521593918, "energy": 60839.95655488258, "forces": 0.8570244825856543, "n_frames": 15}}}
+{"epoch": 2, "step": 26211, "train_s": 5895.176504135132, "frames_per_s": 253.58189003355633, "valid_loss": 49.370246826917274, "improved": true, "lr": 0.0009983736090362072, "valid": {"all": {"dipole": 0.3406762272011869, "polar_diag": 0.03791492124129491, "polar_offdiag": 0.02394933664174905, "energy": 54502.35953591734, "forces": 0.5356341267857878, "n_frames": 20000}, "dimers": {"dipole": 0.19431698039320683, "polar_diag": 0.012988662195219328, "polar_offdiag": 0.007798515727197347, "energy": 24680.375026222733, "forces": 0.4017369058694314, "n_frames": 3823}, "monomers": {"dipole": 0.12873961231726289, "polar_diag": 0.010474442157038535, "polar_offdiag": 0.007903321976945902, "energy": 18201.68487020599, "forces": 0.4838120274046543, "n_frames": 210}, "pubchem": {"dipole": 0.352400473856957, "polar_diag": 0.0428656054580601, "polar_offdiag": 0.026267882862212513, "energy": 59326.167517022695, "forces": 0.5718355506799562, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.7265740831810487, "polar_diag": 0.08016068411638783, "polar_offdiag": 0.06907093276514567, "energy": 139660.32106213807, "forces": 0.5330617879986508, "n_frames": 156}, "water": {"dipole": 0.6109309865938598, "polar_diag": 0.018272396640946056, "polar_offdiag": 0.01845906665816395, "energy": 62417.84477443701, "forces": 0.6208832810603309, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.42528479200489816, "polar_diag": 0.031299154103397744, "polar_offdiag": 0.023154532182056643, "energy": 54237.79890821533, "forces": 0.3912279623878555, "n_frames": 1799}, "dipeptides": {"dipole": 0.45585384971389054, "polar_diag": 0.013607045494227586, "polar_offdiag": 0.009844826384172414, "energy": 29782.323512377578, "forces": 0.4999562431322943, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.5874339614438522, "polar_diag": 0.031041915834416803, "polar_offdiag": 0.02136191788580556, "energy": 60842.47274396398, "forces": 0.5376554054024761, "n_frames": 15}}}
+{"epoch": 3, "step": 39316, "train_s": 5894.160732746124, "frames_per_s": 253.6255911201649, "valid_loss": 42.645146843345685, "improved": true, "lr": 0.0009962458861991763, "valid": {"all": {"dipole": 0.3054051247894815, "polar_diag": 0.03548467435832168, "polar_offdiag": 0.022120015233645585, "energy": 54501.76429455473, "forces": 0.4826270309034945, "n_frames": 20000}, "dimers": {"dipole": 0.1619652873420662, "polar_diag": 0.011386460657318192, "polar_offdiag": 0.007043077413041375, "energy": 24679.872794506482, "forces": 0.35973082295304637, "n_frames": 3823}, "monomers": {"dipole": 0.11158578238361454, "polar_diag": 0.009300823345111826, "polar_offdiag": 0.007124391217994777, "energy": 18201.429829758403, "forces": 0.4104679584923975, "n_frames": 210}, "pubchem": {"dipole": 0.31781998389668037, "polar_diag": 0.040431850793744395, "polar_offdiag": 0.024330436463154057, "energy": 59325.6345534814, "forces": 0.5156529990926586, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.5717462245826819, "polar_diag": 0.07333626609084305, "polar_offdiag": 0.0632469333812471, "energy": 139655.21972453338, "forces": 0.47860102788833664, "n_frames": 156}, "water": {"dipole": 0.6323984889777419, "polar_diag": 0.017757865838011557, "polar_offdiag": 0.011558832886794069, "energy": 62411.19079139574, "forces": 0.4461752575926214, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.39005482832749944, "polar_diag": 0.027015607344689562, "polar_offdiag": 0.02108066725704667, "energy": 54237.29940395997, "forces": 0.3553887058622122, "n_frames": 1799}, "dipeptides": {"dipole": 0.42374077673585864, "polar_diag": 0.01214675376734533, "polar_offdiag": 0.009102979373610025, "energy": 29782.57864577607, "forces": 0.4365350419641493, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.42237391855985074, "polar_diag": 0.025361891733607627, "polar_offdiag": 0.016819236530487943, "energy": 60837.04359242538, "forces": 0.4529779271533964, "n_frames": 15}}}
+{"epoch": 4, "step": 52421, "train_s": 5890.038329362869, "frames_per_s": 253.80310218825107, "valid_loss": 34.53323552389254, "improved": true, "lr": 0.0009932456305250525, "valid": {"all": {"dipole": 0.2848970424875174, "polar_diag": 0.031383920894296494, "polar_offdiag": 0.020023620877976885, "energy": 54501.41727765986, "forces": 0.4463319893013603, "n_frames": 20000}, "dimers": {"dipole": 0.15307855632317405, "polar_diag": 0.010685464303601351, "polar_offdiag": 0.006596283006936062, "energy": 24679.73843851814, "forces": 0.32908597209838875, "n_frames": 3823}, "monomers": {"dipole": 0.10256307884376123, "polar_diag": 0.008841236273754239, "polar_offdiag": 0.006264371234468715, "energy": 18201.335528183743, "forces": 0.3757571934774418, "n_frames": 210}, "pubchem": {"dipole": 0.295609116689011, "polar_diag": 0.03525541708089646, "polar_offdiag": 0.021819795345489553, "energy": 59325.31764453543, "forces": 0.4788255919185227, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.5574284012588112, "polar_diag": 0.08026852039842848, "polar_offdiag": 0.061335780633496935, "energy": 139654.051808985, "forces": 0.4462215309494741, "n_frames": 156}, "water": {"dipole": 0.5074549943125322, "polar_diag": 0.013003680022662601, "polar_offdiag": 0.01034138346442304, "energy": 62410.61770472805, "forces": 0.4158483868656089, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.3594695300194067, "polar_diag": 0.024941697210343044, "polar_offdiag": 0.019594724438431365, "energy": 54236.53416576892, "forces": 0.3157310297967083, "n_frames": 1799}, "dipeptides": {"dipole": 0.42853366897392425, "polar_diag": 0.011131294279904311, "polar_offdiag": 0.008629218308615575, "energy": 29781.898565869757, "forces": 0.4000494018511575, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.42409007956741607, "polar_diag": 0.020042724665135236, "polar_offdiag": 0.015650909519007924, "energy": 60835.41873612772, "forces": 0.4076183952341225, "n_frames": 15}}}
+{"epoch": 5, "step": 65526, "train_s": 5889.487315893173, "frames_per_s": 253.82684770640154, "valid_loss": 30.71271487488144, "improved": true, "lr": 0.0009893779642879963, "valid": {"all": {"dipole": 0.2726516080095005, "polar_diag": 0.029416241968072097, "polar_offdiag": 0.01879914132518905, "energy": 54500.69071990923, "forces": 0.42262094337152, "n_frames": 20000}, "dimers": {"dipole": 0.14865831584383343, "polar_diag": 0.00982578362320015, "polar_offdiag": 0.0062171950824048625, "energy": 24679.701668077763, "forces": 0.31010200616439365, "n_frames": 3823}, "monomers": {"dipole": 0.09973732038541964, "polar_diag": 0.008113371803797594, "polar_offdiag": 0.005468388683899859, "energy": 18201.259443602612, "forces": 0.3577977757569289, "n_frames": 210}, "pubchem": {"dipole": 0.2805125902762293, "polar_diag": 0.03293670873074924, "polar_offdiag": 0.0203923284348238, "energy": 59324.607603369, "forces": 0.4536061034560963, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.5378168334280146, "polar_diag": 0.07947687325852895, "polar_offdiag": 0.06186942233023853, "energy": 139651.45611366417, "forces": 0.43321167100904756, "n_frames": 156}, "water": {"dipole": 0.5010938373471402, "polar_diag": 0.01264453411932801, "polar_offdiag": 0.009505715021518745, "energy": 62405.27538140162, "forces": 0.40359509939821087, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.35466486981978296, "polar_diag": 0.023508215879783537, "polar_offdiag": 0.017972917997066053, "energy": 54235.144879702224, "forces": 0.29574955468064784, "n_frames": 1799}, "dipeptides": {"dipole": 0.41748946660985725, "polar_diag": 0.010417491083867447, "polar_offdiag": 0.00805524500592142, "energy": 29780.33148812916, "forces": 0.37735479904619146, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.4298911118947136, "polar_diag": 0.018541913905977772, "polar_offdiag": 0.015254346921489722, "energy": 60831.74750079106, "forces": 0.39422588487717825, "n_frames": 15}}}
+{"epoch": 6, "step": 78631, "train_s": 5892.123333930969, "frames_per_s": 253.71329065555403, "valid_loss": 28.086545884609222, "improved": true, "lr": 0.0009846498724073172, "valid": {"all": {"dipole": 0.2625810282663142, "polar_diag": 0.027981470295273782, "polar_offdiag": 0.018007698855916705, "energy": 54500.83393146934, "forces": 0.4022695677057412, "n_frames": 20000}, "dimers": {"dipole": 0.14198211423586374, "polar_diag": 0.009413068180086099, "polar_offdiag": 0.006038537018019646, "energy": 24679.971492158977, "forces": 0.29605728998636466, "n_frames": 3823}, "monomers": {"dipole": 0.09946600542334474, "polar_diag": 0.00785541855757339, "polar_offdiag": 0.0050582725917179445, "energy": 18201.5016272206, "forces": 0.34228235889710873, "n_frames": 210}, "pubchem": {"dipole": 0.272402287346951, "polar_diag": 0.031216768605183444, "polar_offdiag": 0.019418746548088072, "energy": 59324.752627951995, "forces": 0.43209804234005444, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.5108335639894692, "polar_diag": 0.07730795108293956, "polar_offdiag": 0.0596021492585313, "energy": 139651.13047326735, "forces": 0.40739063795896874, "n_frames": 156}, "water": {"dipole": 0.43077852527878047, "polar_diag": 0.011935409528424779, "polar_offdiag": 0.008687476056741382, "energy": 62404.65565049728, "forces": 0.37694034918174985, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.3300364440906642, "polar_diag": 0.02298976960682698, "polar_offdiag": 0.018031003335084363, "energy": 54235.338283687044, "forces": 0.2792988027737992, "n_frames": 1799}, "dipeptides": {"dipole": 0.39857853732237336, "polar_diag": 0.010014526946239716, "polar_offdiag": 0.00786836705283671, "energy": 29780.389311198243, "forces": 0.3603212338656387, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.4492084918486432, "polar_diag": 0.017331908703193268, "polar_offdiag": 0.013999742488654647, "energy": 60831.23913253781, "forces": 0.3704281590754851, "n_frames": 15}}}
+{"epoch": 7, "step": 91737, "train_s": 5895.158571004868, "frames_per_s": 253.58266143215602, "valid_loss": 26.02212169937704, "improved": true, "lr": 0.0009790693875402212, "valid": {"all": {"dipole": 0.2536582668460106, "polar_diag": 0.026930225545424145, "polar_offdiag": 0.017511653102851337, "energy": 54501.114629159645, "forces": 0.3834299635974062, "n_frames": 20000}, "dimers": {"dipole": 0.14337812690884866, "polar_diag": 0.009237123908395053, "polar_offdiag": 0.00598646456325228, "energy": 24680.0224579354, "forces": 0.2840768952237517, "n_frames": 3823}, "monomers": {"dipole": 0.1016393275431941, "polar_diag": 0.0073601434068848, "polar_offdiag": 0.004841783655964232, "energy": 18201.65593722568, "forces": 0.31957767297104944, "n_frames": 210}, "pubchem": {"dipole": 0.2608673658202219, "polar_diag": 0.030272349853357645, "polar_offdiag": 0.01908612106756206, "energy": 59325.143935369815, "forces": 0.4115919519193688, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.5087437224238643, "polar_diag": 0.07150998134624086, "polar_offdiag": 0.05586065473635864, "energy": 139649.17887114343, "forces": 0.3890542810003379, "n_frames": 156}, "water": {"dipole": 0.43505244974227475, "polar_diag": 0.010697332958828165, "polar_offdiag": 0.009015110549735342, "energy": 62402.18457714441, "forces": 0.3738264285796735, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.3228190474231712, "polar_diag": 0.020365539213125654, "polar_offdiag": 0.01633483626188162, "energy": 54235.60553016822, "forces": 0.2671792948039197, "n_frames": 1799}, "dipeptides": {"dipole": 0.39641684993924, "polar_diag": 0.009577262173736615, "polar_offdiag": 0.007541544030095254, "energy": 29780.650636386887, "forces": 0.3440223430391872, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.45013518245627576, "polar_diag": 0.016106694413283686, "polar_offdiag": 0.013883099471070626, "energy": 60828.062015268355, "forces": 0.35128336823705497, "n_frames": 15}}}
+{"epoch": 8, "step": 104842, "train_s": 5894.630712032318, "frames_per_s": 253.60536953545528, "valid_loss": 24.46588615507915, "improved": true, "lr": 0.0009726470452733338, "valid": {"all": {"dipole": 0.24776022993193936, "polar_diag": 0.02604884225782189, "polar_offdiag": 0.01693485559557528, "energy": 54501.05966482487, "forces": 0.36895200055067223, "n_frames": 20000}, "dimers": {"dipole": 0.14024098786320907, "polar_diag": 0.008959690775561463, "polar_offdiag": 0.005756938703703339, "energy": 24680.12205035891, "forces": 0.27241521700416965, "n_frames": 3823}, "monomers": {"dipole": 0.09833260327330634, "polar_diag": 0.007068949337749045, "polar_offdiag": 0.004479099475952292, "energy": 18201.75559507536, "forces": 0.3087136085954967, "n_frames": 210}, "pubchem": {"dipole": 0.25563834166931265, "polar_diag": 0.029190427214887158, "polar_offdiag": 0.018373711407252965, "energy": 59325.09885506643, "forces": 0.3955967109818273, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.4816632082526205, "polar_diag": 0.07109080073660759, "polar_offdiag": 0.055872049410544064, "energy": 139648.6520467045, "forces": 0.3799563248671237, "n_frames": 156}, "water": {"dipole": 0.44289082310825334, "polar_diag": 0.01529228548360848, "polar_offdiag": 0.00881339725596578, "energy": 62401.520860587094, "forces": 0.37372266612450433, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.3108139884317928, "polar_diag": 0.02006863964653916, "polar_offdiag": 0.01600865822941473, "energy": 54235.41032198221, "forces": 0.2601554666167596, "n_frames": 1799}, "dipeptides": {"dipole": 0.39659238889323545, "polar_diag": 0.00936892414213615, "polar_offdiag": 0.007373828385086636, "energy": 29780.387065644256, "forces": 0.328808040065654, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.39506897157845766, "polar_diag": 0.01915185087170895, "polar_offdiag": 0.013564980230944918, "energy": 60827.84934112554, "forces": 0.33982417035150464, "n_frames": 15}}}
+{"epoch": 9, "step": 117947, "train_s": 5894.522357940674, "frames_per_s": 253.61003135159297, "valid_loss": 23.662804688530407, "improved": true, "lr": 0.0009653941378928721, "valid": {"all": {"dipole": 0.23820833344362502, "polar_diag": 0.025707847976723548, "polar_offdiag": 0.01650538918411801, "energy": 54500.4363743264, "forces": 0.3543660187720102, "n_frames": 20000}, "dimers": {"dipole": 0.13708575419826943, "polar_diag": 0.008580525041463304, "polar_offdiag": 0.005646445449684498, "energy": 24679.90976004693, "forces": 0.2651050194594564, "n_frames": 3823}, "monomers": {"dipole": 0.0946040334070257, "polar_diag": 0.006553572489972786, "polar_offdiag": 0.004321835216279608, "energy": 18201.55413563306, "forces": 0.2897212725636265, "n_frames": 210}, "pubchem": {"dipole": 0.24464670261775262, "polar_diag": 0.028840585985112164, "polar_offdiag": 0.017883170092828506, "energy": 59324.524636399234, "forces": 0.3790711961210904, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.4591403028279545, "polar_diag": 0.07167554796886001, "polar_offdiag": 0.05603351799919558, "energy": 139646.09987191157, "forces": 0.3630401899839186, "n_frames": 156}, "water": {"dipole": 0.48020642570508376, "polar_diag": 0.013948220241085238, "polar_offdiag": 0.00946527217507452, "energy": 62395.39235735738, "forces": 0.3654107107883391, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.30414528090194365, "polar_diag": 0.01925528475960556, "polar_offdiag": 0.015313330997262755, "energy": 54234.17648504088, "forces": 0.2556872832545234, "n_frames": 1799}, "dipeptides": {"dipole": 0.3808122976216128, "polar_diag": 0.009008091935345039, "polar_offdiag": 0.007179583635614046, "energy": 29779.28251325209, "forces": 0.3140937019661634, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3678632987814302, "polar_diag": 0.01805414135768681, "polar_offdiag": 0.011750337956540458, "energy": 60823.85047988987, "forces": 0.32089418144297854, "n_frames": 15}}}
+{"epoch": 10, "step": 131053, "train_s": 5895.253442287445, "frames_per_s": 253.57858057073673, "valid_loss": 23.40765635343804, "improved": true, "lr": 0.0009573225979693234, "valid": {"all": {"dipole": 0.23445857383746085, "polar_diag": 0.02550577901228844, "polar_offdiag": 0.01627597362117153, "energy": 54500.5133303091, "forces": 0.3466694399924457, "n_frames": 20000}, "dimers": {"dipole": 0.13553535369198744, "polar_diag": 0.008504669919124429, "polar_offdiag": 0.005622492557509774, "energy": 24679.902059801658, "forces": 0.2596061674394637, "n_frames": 3823}, "monomers": {"dipole": 0.09507620369184844, "polar_diag": 0.006015031077913405, "polar_offdiag": 0.004217618465893954, "energy": 18201.57128120432, "forces": 0.2873255554466997, "n_frames": 210}, "pubchem": {"dipole": 0.2414571125640168, "polar_diag": 0.028429359978857538, "polar_offdiag": 0.017515228367161108, "energy": 59324.607681228576, "forces": 0.37093996131995927, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.4374041376599708, "polar_diag": 0.07534283688212297, "polar_offdiag": 0.05836161707603133, "energy": 139645.55837015662, "forces": 0.35647210402817003, "n_frames": 156}, "water": {"dipole": 0.43066978636145553, "polar_diag": 0.010416016804981686, "polar_offdiag": 0.009692011913946297, "energy": 62394.73062000394, "forces": 0.3598141314759403, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2956521141846458, "polar_diag": 0.01985028062346143, "polar_offdiag": 0.015114175293823385, "energy": 54234.46390915156, "forces": 0.24931730801078672, "n_frames": 1799}, "dipeptides": {"dipole": 0.37999194219632193, "polar_diag": 0.008680106257361068, "polar_offdiag": 0.006952104842806137, "energy": 29779.482935712087, "forces": 0.3032578637962151, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3797930535426986, "polar_diag": 0.01644204488565121, "polar_offdiag": 0.011586039273865442, "energy": 60823.20118726625, "forces": 0.3130171191995754, "n_frames": 15}}}
+{"epoch": 11, "step": 144158, "train_s": 5894.186796665192, "frames_per_s": 253.62446959532892, "valid_loss": 21.983480497338306, "improved": true, "lr": 0.0009484481997787952, "valid": {"all": {"dipole": 0.23384200224783389, "polar_diag": 0.024555062445325418, "polar_offdiag": 0.015947111217851404, "energy": 54499.44233931206, "forces": 0.3358940940653546, "n_frames": 20000}, "dimers": {"dipole": 0.13166566070207733, "polar_diag": 0.008172773620757724, "polar_offdiag": 0.005454159935513392, "energy": 24679.37760178333, "forces": 0.2510362216448074, "n_frames": 3823}, "monomers": {"dipole": 0.0950440723803342, "polar_diag": 0.005702838741217719, "polar_offdiag": 0.004040579515842087, "energy": 18201.136207338684, "forces": 0.27465426474284715, "n_frames": 210}, "pubchem": {"dipole": 0.2423675497509002, "polar_diag": 0.027454940108309782, "polar_offdiag": 0.017167269224143387, "energy": 59323.698883497935, "forces": 0.3590536629550476, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.434948637298785, "polar_diag": 0.07095634264202402, "polar_offdiag": 0.057001029083121706, "energy": 139639.94505430467, "forces": 0.3514312634295359, "n_frames": 156}, "water": {"dipole": 0.4424376624653912, "polar_diag": 0.0111381817928435, "polar_offdiag": 0.009035770362595971, "energy": 62383.18103005466, "forces": 0.35786617239017204, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2909600774583075, "polar_diag": 0.01866312225451386, "polar_offdiag": 0.01485542838184523, "energy": 54232.15557324989, "forces": 0.24293476498025632, "n_frames": 1799}, "dipeptides": {"dipole": 0.36708641190161995, "polar_diag": 0.008871107297360155, "polar_offdiag": 0.0069401560393641286, "energy": 29777.410154240708, "forces": 0.29679201619070655, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.35255683156721085, "polar_diag": 0.01638292061729574, "polar_offdiag": 0.01139747052491945, "energy": 60814.949460364325, "forces": 0.3061481584801824, "n_frames": 15}}}
+{"epoch": 12, "step": 157263, "train_s": 5891.978798866272, "frames_per_s": 253.71951445033184, "valid_loss": 20.737240019543417, "improved": true, "lr": 0.000938786135520786, "valid": {"all": {"dipole": 0.22452680774285982, "polar_diag": 0.024010058686354793, "polar_offdiag": 0.015564832642233824, "energy": 54499.32901693378, "forces": 0.3296847240940913, "n_frames": 20000}, "dimers": {"dipole": 0.13202137783967696, "polar_diag": 0.007982477658300211, "polar_offdiag": 0.005325501683355106, "energy": 24679.34002766057, "forces": 0.24851337383785274, "n_frames": 3823}, "monomers": {"dipole": 0.09293592101587053, "polar_diag": 0.005641178093251891, "polar_offdiag": 0.0038612331947741664, "energy": 18201.147995191324, "forces": 0.26608595005399255, "n_frames": 210}, "pubchem": {"dipole": 0.2312415482506755, "polar_diag": 0.0269964292679773, "polar_offdiag": 0.016801564395571286, "energy": 59323.655211126235, "forces": 0.3521664698727259, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.41112421046399933, "polar_diag": 0.06312466642112138, "polar_offdiag": 0.053279509009415464, "energy": 139637.81541747245, "forces": 0.34528256471822466, "n_frames": 156}, "water": {"dipole": 0.41698423045991817, "polar_diag": 0.012795165327329704, "polar_offdiag": 0.008903092278221352, "energy": 62377.85189357792, "forces": 0.3471124583335385, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.281595806909583, "polar_diag": 0.01851693522148714, "polar_offdiag": 0.014859862519677764, "energy": 54231.83532712409, "forces": 0.23957713621464308, "n_frames": 1799}, "dipeptides": {"dipole": 0.36600363853577095, "polar_diag": 0.008550869991056236, "polar_offdiag": 0.00674799739795811, "energy": 29777.18052249722, "forces": 0.28883693101975483, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.34237749465900746, "polar_diag": 0.017140893378591347, "polar_offdiag": 0.011008425494945769, "energy": 60811.911254292936, "forces": 0.2988246182826465, "n_frames": 15}}}
+{"epoch": 13, "step": 170368, "train_s": 5889.666121006012, "frames_per_s": 253.81914174528026, "valid_loss": 20.53906641575112, "improved": true, "lr": 0.0009283534600399435, "valid": {"all": {"dipole": 0.2220035583281891, "polar_diag": 0.023552568431860862, "polar_offdiag": 0.015561512108646895, "energy": 54498.66551930974, "forces": 0.32318376583556313, "n_frames": 20000}, "dimers": {"dipole": 0.12876104321333764, "polar_diag": 0.007671857487453331, "polar_offdiag": 0.005250040450800685, "energy": 24679.07464115307, "forces": 0.2457349516268725, "n_frames": 3823}, "monomers": {"dipole": 0.09056334086607831, "polar_diag": 0.005474263394146222, "polar_offdiag": 0.0037735253360522683, "energy": 18200.87901592615, "forces": 0.25103121719578825, "n_frames": 210}, "pubchem": {"dipole": 0.22945990007509945, "polar_diag": 0.026347864193895686, "polar_offdiag": 0.016729078153596914, "energy": 59323.049105462815, "forces": 0.344756172208891, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3927080222004507, "polar_diag": 0.0679573701593695, "polar_offdiag": 0.0559189794996091, "energy": 139635.36533598078, "forces": 0.34519659536302294, "n_frames": 156}, "water": {"dipole": 0.37584029956310944, "polar_diag": 0.011890499929910195, "polar_offdiag": 0.008379599872146771, "energy": 62374.017154581285, "forces": 0.3415484263314699, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2770766929836661, "polar_diag": 0.017942288868317096, "polar_offdiag": 0.014671394115408336, "energy": 54230.45826402727, "forces": 0.23605770047709213, "n_frames": 1799}, "dipeptides": {"dipole": 0.3609282034191142, "polar_diag": 0.008244274429993668, "polar_offdiag": 0.006629223631869648, "energy": 29775.764233787893, "forces": 0.2819941861315805, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3494411051718161, "polar_diag": 0.01637630037490372, "polar_offdiag": 0.011110335892548744, "energy": 60808.41654025644, "forces": 0.30170611571913303, "n_frames": 15}}}
+{"epoch": 14, "step": 183473, "train_s": 5894.541146278381, "frames_per_s": 253.60922299165506, "valid_loss": 20.063514975638224, "improved": true, "lr": 0.0009171687415800989, "valid": {"all": {"dipole": 0.21877266728715905, "polar_diag": 0.023715583978026412, "polar_offdiag": 0.015212084785841221, "energy": 54498.33780575698, "forces": 0.3168153890887592, "n_frames": 20000}, "dimers": {"dipole": 0.12782065886181565, "polar_diag": 0.00731126811823307, "polar_offdiag": 0.005252464994508985, "energy": 24678.901115993063, "forces": 0.24042001174316496, "n_frames": 3823}, "monomers": {"dipole": 0.09002543337286055, "polar_diag": 0.0057102763562970746, "polar_offdiag": 0.0036443990526593235, "energy": 18200.758992023224, "forces": 0.2525358730840377, "n_frames": 210}, "pubchem": {"dipole": 0.22586590040486226, "polar_diag": 0.026728332006503354, "polar_offdiag": 0.01641758730917481, "energy": 59322.70652339107, "forces": 0.33729637434014226, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.395813878413985, "polar_diag": 0.06602713206269246, "polar_offdiag": 0.05411324055872257, "energy": 139634.3491882666, "forces": 0.33680300910035776, "n_frames": 156}, "water": {"dipole": 0.3565725558529709, "polar_diag": 0.012151399958920403, "polar_offdiag": 0.008584462370599724, "energy": 62372.499434560785, "forces": 0.3371431626554632, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.27353016584120327, "polar_diag": 0.01693487860088129, "polar_offdiag": 0.013870427282592922, "energy": 54230.07572396739, "forces": 0.23686743696697757, "n_frames": 1799}, "dipeptides": {"dipole": 0.3501759330683653, "polar_diag": 0.008391076573507439, "polar_offdiag": 0.006434564686307143, "energy": 29775.771252233015, "forces": 0.2759320193691978, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3548081572294155, "polar_diag": 0.015449352917555476, "polar_offdiag": 0.010097820884039663, "energy": 60807.362361257976, "forces": 0.2941344529022349, "n_frames": 15}}}
+{"epoch": 15, "step": 196579, "train_s": 5895.118153333664, "frames_per_s": 253.58440002676363, "valid_loss": 19.841389500204173, "improved": true, "lr": 0.0009052508976310492, "valid": {"all": {"dipole": 0.2134006349942857, "polar_diag": 0.023134957221626354, "polar_offdiag": 0.015172236626077062, "energy": 54498.68693998416, "forces": 0.31080498411131036, "n_frames": 20000}, "dimers": {"dipole": 0.12691577270878246, "polar_diag": 0.00736461495022188, "polar_offdiag": 0.005095343666426379, "energy": 24679.09267411119, "forces": 0.23523433987316913, "n_frames": 3823}, "monomers": {"dipole": 0.088009893103462, "polar_diag": 0.005272647309572316, "polar_offdiag": 0.0035636652145944344, "energy": 18200.87687264911, "forces": 0.2394601995375204, "n_frames": 210}, "pubchem": {"dipole": 0.21918484789045722, "polar_diag": 0.025797822376451472, "polar_offdiag": 0.01623548826071214, "energy": 59323.06736652162, "forces": 0.3310052923023016, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.38394240756728637, "polar_diag": 0.07133866433461195, "polar_offdiag": 0.057256582133536266, "energy": 139635.40820807556, "forces": 0.3293908473914163, "n_frames": 156}, "water": {"dipole": 0.35339411790314884, "polar_diag": 0.011168900411815426, "polar_offdiag": 0.009480950048052923, "energy": 62371.00278632234, "forces": 0.3182740447093141, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2713559845625332, "polar_diag": 0.017159784946852972, "polar_offdiag": 0.01405277940038998, "energy": 54230.52510277523, "forces": 0.2327768271735523, "n_frames": 1799}, "dipeptides": {"dipole": 0.34554165740808745, "polar_diag": 0.007975109823940223, "polar_offdiag": 0.0064618773616368546, "energy": 29775.898706908607, "forces": 0.2695880384728897, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3329111564921844, "polar_diag": 0.015399262689280874, "polar_offdiag": 0.009694934736428996, "energy": 60808.0275402297, "forces": 0.2802085316072832, "n_frames": 15}}}
+{"epoch": 16, "step": 209684, "train_s": 5894.760150432587, "frames_per_s": 253.5998008146771, "valid_loss": 19.29247329289886, "improved": true, "lr": 0.000892623036634177, "valid": {"all": {"dipole": 0.20977279880624353, "polar_diag": 0.022864691111950605, "polar_offdiag": 0.015026418852847943, "energy": 54497.58296338655, "forces": 0.30504970094978534, "n_frames": 20000}, "dimers": {"dipole": 0.12436074428187428, "polar_diag": 0.0069670231676587134, "polar_offdiag": 0.0051394086462841345, "energy": 24678.57862381806, "forces": 0.23001673174662735, "n_frames": 3823}, "monomers": {"dipole": 0.08825821155942568, "polar_diag": 0.005336865993962416, "polar_offdiag": 0.003399506268439901, "energy": 18200.4032022318, "forces": 0.2362781767607254, "n_frames": 210}, "pubchem": {"dipole": 0.21552148419469314, "polar_diag": 0.025634858205586336, "polar_offdiag": 0.016085049523490644, "energy": 59322.0403368036, "forces": 0.3234819368304616, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3846381129779304, "polar_diag": 0.06583387064524919, "polar_offdiag": 0.05679366524870443, "energy": 139631.46091160006, "forces": 0.32580560417026483, "n_frames": 156}, "water": {"dipole": 0.31734663872451485, "polar_diag": 0.010938177860186728, "polar_offdiag": 0.008110798081187481, "energy": 62364.54875740132, "forces": 0.2975752744424875, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.26646826850088273, "polar_diag": 0.017272790933230225, "polar_offdiag": 0.013777080136751975, "energy": 54228.390210626945, "forces": 0.23859073663576633, "n_frames": 1799}, "dipeptides": {"dipole": 0.3353499769300945, "polar_diag": 0.007925853962058136, "polar_offdiag": 0.006305554960150931, "energy": 29774.068248208536, "forces": 0.264188331008116, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3471252882544197, "polar_diag": 0.013627043991833246, "polar_offdiag": 0.009607337998082673, "energy": 60802.40949611564, "forces": 0.2761396438851353, "n_frames": 15}}}
+{"epoch": 17, "step": 222790, "train_s": 5889.970297336578, "frames_per_s": 253.80603373772402, "valid_loss": 19.089235364363113, "improved": true, "lr": 0.0008793054730631411, "valid": {"all": {"dipole": 0.20572713301816412, "polar_diag": 0.022740207942630097, "polar_offdiag": 0.014951774397103367, "energy": 54497.441486513846, "forces": 0.3000819698933853, "n_frames": 20000}, "dimers": {"dipole": 0.12500532789414817, "polar_diag": 0.006920090138875381, "polar_offdiag": 0.005089087241415571, "energy": 24678.600059752855, "forces": 0.2272320362656449, "n_frames": 3823}, "monomers": {"dipole": 0.08748572356345716, "polar_diag": 0.005022472466782876, "polar_offdiag": 0.003359787183626644, "energy": 18200.402130565297, "forces": 0.23863264243471946, "n_frames": 210}, "pubchem": {"dipole": 0.20975348455208764, "polar_diag": 0.025495173492547422, "polar_offdiag": 0.016026691423375206, "energy": 59321.958868246686, "forces": 0.31717508321109544, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.38510217875509434, "polar_diag": 0.06559212086205188, "polar_offdiag": 0.05572636995741424, "energy": 139629.76138859472, "forces": 0.32411371815922696, "n_frames": 156}, "water": {"dipole": 0.29467788366993547, "polar_diag": 0.01086648626827246, "polar_offdiag": 0.008117776167399442, "energy": 62359.875744401084, "forces": 0.3206581321496773, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.26674071684224326, "polar_diag": 0.01713948850320503, "polar_offdiag": 0.013808803514992099, "energy": 54227.936153668816, "forces": 0.24006906282139845, "n_frames": 1799}, "dipeptides": {"dipole": 0.331162612467443, "polar_diag": 0.007924755659628115, "polar_offdiag": 0.0063215590600915585, "energy": 29773.52751142312, "forces": 0.26113469341329254, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.34468246912808165, "polar_diag": 0.015942192173860274, "polar_offdiag": 0.010073417683207422, "energy": 60799.67606931252, "forces": 0.2766133588486008, "n_frames": 15}}}
+{"epoch": 18, "step": 235895, "train_s": 5889.298810482025, "frames_per_s": 253.83497222781352, "valid_loss": 18.26335538187246, "improved": true, "lr": 0.0008653239929117262, "valid": {"all": {"dipole": 0.20360957922676537, "polar_diag": 0.022073166352979404, "polar_offdiag": 0.014791107004072218, "energy": 54496.462763038115, "forces": 0.29805120742776614, "n_frames": 20000}, "dimers": {"dipole": 0.12472325398748019, "polar_diag": 0.007296912124800139, "polar_offdiag": 0.005065534046809346, "energy": 24678.14894064795, "forces": 0.22438989879510216, "n_frames": 3823}, "monomers": {"dipole": 0.08762344682994985, "polar_diag": 0.004871494406188874, "polar_offdiag": 0.003268954227911282, "energy": 18199.95952690424, "forces": 0.23081876069854526, "n_frames": 210}, "pubchem": {"dipole": 0.20834389098059175, "polar_diag": 0.02479852006935696, "polar_offdiag": 0.01584642272376505, "energy": 59320.96094312706, "forces": 0.3145932380392195, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3898902177089737, "polar_diag": 0.060671303859421634, "polar_offdiag": 0.055419082632374474, "energy": 139627.7504414267, "forces": 0.32400641938782165, "n_frames": 156}, "water": {"dipole": 0.34119084822847057, "polar_diag": 0.011646059853743958, "polar_offdiag": 0.009046684197108064, "energy": 62359.209524908416, "forces": 0.32801813801281166, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2592615133952713, "polar_diag": 0.016481841033190555, "polar_offdiag": 0.01360541712956997, "energy": 54226.36041280835, "forces": 0.2424142340171166, "n_frames": 1799}, "dipeptides": {"dipole": 0.3154678963995852, "polar_diag": 0.007932807890315825, "polar_offdiag": 0.006164254477982517, "energy": 29772.281477226155, "forces": 0.2537693210756255, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3254726038490113, "polar_diag": 0.016194803310776225, "polar_offdiag": 0.010620325580954168, "energy": 60797.580302728056, "forces": 0.2739757469049139, "n_frames": 15}}}
+{"epoch": 19, "step": 249000, "train_s": 5895.855509996414, "frames_per_s": 253.55268585964876, "valid_loss": 18.940654946812266, "improved": false, "lr": 0.0008507025195285678, "valid": {"all": {"dipole": 0.20124855291002294, "polar_diag": 0.022867693630020402, "polar_offdiag": 0.01476565139149002, "energy": 54497.14942945181, "forces": 0.29406664349548, "n_frames": 20000}, "dimers": {"dipole": 0.12251387470340662, "polar_diag": 0.007137533421471248, "polar_offdiag": 0.005013682723335413, "energy": 24678.50703851457, "forces": 0.22194000225850918, "n_frames": 3823}, "monomers": {"dipole": 0.08776547734168078, "polar_diag": 0.00469750797407017, "polar_offdiag": 0.003246134418135668, "energy": 18200.259598357905, "forces": 0.2241168561727132, "n_frames": 210}, "pubchem": {"dipole": 0.20619183203711475, "polar_diag": 0.02576231400269953, "polar_offdiag": 0.01583534701177903, "energy": 59321.56784876149, "forces": 0.311042057871598, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3887344727408486, "polar_diag": 0.06444627657037498, "polar_offdiag": 0.056828316381413106, "energy": 139631.29167478625, "forces": 0.3141407925972812, "n_frames": 156}, "water": {"dipole": 0.29519859764284395, "polar_diag": 0.010419860303089687, "polar_offdiag": 0.008953424461160327, "energy": 62362.79242350476, "forces": 0.3071365716290352, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.25419544219682255, "polar_diag": 0.01617413313661466, "polar_offdiag": 0.012922826910221811, "energy": 54227.66685404762, "forces": 0.23546942138656826, "n_frames": 1799}, "dipeptides": {"dipole": 0.3174038147976465, "polar_diag": 0.00767141937078201, "polar_offdiag": 0.006118078957693996, "energy": 29773.44833730009, "forces": 0.25308536799643466, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.32052841559396766, "polar_diag": 0.014145092058083432, "polar_offdiag": 0.0101547555200894, "energy": 60801.9413023411, "forces": 0.26911486738381646, "n_frames": 15}}}
+{"epoch": 20, "step": 262105, "train_s": 5894.609674692154, "frames_per_s": 253.60627463057114, "valid_loss": 18.454518917305716, "improved": false, "lr": 0.0008354668971151114, "valid": {"all": {"dipole": 0.19857312560941384, "polar_diag": 0.022277916681377064, "polar_offdiag": 0.014720245166395024, "energy": 54496.9846397248, "forces": 0.28937847807553485, "n_frames": 20000}, "dimers": {"dipole": 0.12161046366260864, "polar_diag": 0.006879354096679152, "polar_offdiag": 0.005002282961041522, "energy": 24678.285497751935, "forces": 0.2194516686018665, "n_frames": 3823}, "monomers": {"dipole": 0.08650747752925449, "polar_diag": 0.004631022150534669, "polar_offdiag": 0.0030949121471058405, "energy": 18200.06026572963, "forces": 0.2176932828055845, "n_frames": 210}, "pubchem": {"dipole": 0.20285829875192765, "polar_diag": 0.025005646620129638, "polar_offdiag": 0.015531545510004787, "energy": 59321.49495837344, "forces": 0.30419453383874834, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3983321244723112, "polar_diag": 0.06375687058670694, "polar_offdiag": 0.056639785855949684, "energy": 139629.55792583496, "forces": 0.31180723505563296, "n_frames": 156}, "water": {"dipole": 0.2573681286596598, "polar_diag": 0.01113103063663729, "polar_offdiag": 0.008342230880751913, "energy": 62360.97915477961, "forces": 0.3079073243848436, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2520370245629183, "polar_diag": 0.016555584539246732, "polar_offdiag": 0.01507653365733293, "energy": 54227.121637880766, "forces": 0.2435416839679137, "n_frames": 1799}, "dipeptides": {"dipole": 0.3121888148883338, "polar_diag": 0.007827615711947051, "polar_offdiag": 0.00608749966383409, "energy": 29772.841890226202, "forces": 0.2469734967317822, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.31799747879833595, "polar_diag": 0.014338156781427447, "polar_offdiag": 0.009684137669673397, "energy": 60799.36897918158, "forces": 0.2639482027224115, "n_frames": 15}}}
+{"epoch": 21, "step": 275210, "train_s": 5894.513591527939, "frames_per_s": 253.6104085243951, "valid_loss": 18.442702116637395, "improved": false, "lr": 0.0008196442504413426, "valid": {"all": {"dipole": 0.1955048726077077, "polar_diag": 0.022305283773390572, "polar_offdiag": 0.014584281933713967, "energy": 54496.35426942981, "forces": 0.28678549917478047, "n_frames": 20000}, "dimers": {"dipole": 0.12088849924349897, "polar_diag": 0.006857666377466131, "polar_offdiag": 0.005070020170913994, "energy": 24678.16248079911, "forces": 0.21849803649426552, "n_frames": 3823}, "monomers": {"dipole": 0.08501515585509829, "polar_diag": 0.004714416246134594, "polar_offdiag": 0.0030720670151220294, "energy": 18199.946666588523, "forces": 0.2164233283975015, "n_frames": 210}, "pubchem": {"dipole": 0.20002332396983602, "polar_diag": 0.024956341199485935, "polar_offdiag": 0.015502740548392936, "energy": 59320.82832364547, "forces": 0.3017463187610307, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3802588469136061, "polar_diag": 0.0677601618373768, "polar_offdiag": 0.05918137022123983, "energy": 139628.08929952417, "forces": 0.3077298567898298, "n_frames": 156}, "water": {"dipole": 0.27617784484548585, "polar_diag": 0.009226734167720501, "polar_offdiag": 0.008080744963791072, "energy": 62359.19486330785, "forces": 0.29296622332739813, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2469958664659832, "polar_diag": 0.01618241130728312, "polar_offdiag": 0.012768123708231069, "energy": 54226.17957304739, "forces": 0.23965770249384405, "n_frames": 1799}, "dipeptides": {"dipole": 0.3043581015255782, "polar_diag": 0.007658344921829973, "polar_offdiag": 0.006009712879681595, "energy": 29772.100379587682, "forces": 0.2422098834413949, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.32555656542167516, "polar_diag": 0.014325746343432992, "polar_offdiag": 0.009666389546142304, "energy": 60797.8464179996, "forces": 0.2606149858665743, "n_frames": 15}}}
+{"epoch": 22, "step": 288316, "train_s": 5895.042069911957, "frames_per_s": 253.58767287344003, "valid_loss": 18.51626445198881, "improved": false, "lr": 0.0008032614132389426, "valid": {"all": {"dipole": 0.19316825671603713, "polar_diag": 0.022404361314872175, "polar_offdiag": 0.014646876037261808, "energy": 54495.94959680582, "forces": 0.283519915408686, "n_frames": 20000}, "dimers": {"dipole": 0.12246942268964393, "polar_diag": 0.00675746783241459, "polar_offdiag": 0.004946720472383199, "energy": 24677.950027102164, "forces": 0.21502239840912793, "n_frames": 3823}, "monomers": {"dipole": 0.08737079483613906, "polar_diag": 0.004757956659110291, "polar_offdiag": 0.0030493260943546497, "energy": 18199.687314948704, "forces": 0.2140145055812894, "n_frames": 210}, "pubchem": {"dipole": 0.1967968628934742, "polar_diag": 0.025254809203699782, "polar_offdiag": 0.01562032698041587, "energy": 59320.410715835234, "forces": 0.2972726900674178, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.38736426545343733, "polar_diag": 0.06416370224136966, "polar_offdiag": 0.058942175100300295, "energy": 139627.7891788535, "forces": 0.3060023466224038, "n_frames": 156}, "water": {"dipole": 0.26818053765459693, "polar_diag": 0.009574683007489686, "polar_offdiag": 0.008260291503375152, "energy": 62358.36061255711, "forces": 0.30399144071704903, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2438397280806823, "polar_diag": 0.01549607285929806, "polar_offdiag": 0.012674539366461821, "energy": 54225.47296119676, "forces": 0.2436332552865907, "n_frames": 1799}, "dipeptides": {"dipole": 0.3040403393653014, "polar_diag": 0.007495421180476468, "polar_offdiag": 0.005898299806588273, "energy": 29771.64552484701, "forces": 0.23952007941277295, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.31433078236655543, "polar_diag": 0.017324508172147514, "polar_offdiag": 0.009798729074122964, "energy": 60797.43545468564, "forces": 0.25827027257891083, "n_frames": 15}}}
+{"epoch": 23, "step": 301421, "train_s": 5894.543174028397, "frames_per_s": 253.60913574891364, "valid_loss": 18.905937842596536, "improved": false, "lr": 0.0007863499922677875, "valid": {"all": {"dipole": 0.19097862726168108, "polar_diag": 0.02334430161221478, "polar_offdiag": 0.014472475778753137, "energy": 54495.18387985492, "forces": 0.2837511866007186, "n_frames": 20000}, "dimers": {"dipole": 0.11979145689840806, "polar_diag": 0.006714901414237589, "polar_offdiag": 0.004936135429972189, "energy": 24677.650419128975, "forces": 0.21192636507819598, "n_frames": 3823}, "monomers": {"dipole": 0.08399439146819948, "polar_diag": 0.004557094115562225, "polar_offdiag": 0.002971441199188381, "energy": 18199.3893775117, "forces": 0.21036066713419005, "n_frames": 210}, "pubchem": {"dipole": 0.19448146471192024, "polar_diag": 0.026485666474429355, "polar_offdiag": 0.015516837920196296, "energy": 59319.691912522445, "forces": 0.2955505045807749, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.38410957528786566, "polar_diag": 0.06401112473106123, "polar_offdiag": 0.05736688586708106, "energy": 139625.3870619707, "forces": 0.3052226785141029, "n_frames": 156}, "water": {"dipole": 0.24866123447264335, "polar_diag": 0.011947791447576987, "polar_offdiag": 0.008373467347337356, "energy": 62356.587096197894, "forces": 0.3047636672566933, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.24348030834253961, "polar_diag": 0.015349267485708326, "polar_offdiag": 0.012036532993780174, "energy": 54223.908863754026, "forces": 0.2577772503829434, "n_frames": 1799}, "dipeptides": {"dipole": 0.29740333623561227, "polar_diag": 0.007335783981431784, "polar_offdiag": 0.00589701269994626, "energy": 29770.198928266695, "forces": 0.23893148526085864, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.31293318077157367, "polar_diag": 0.014548916416301745, "polar_offdiag": 0.010318586669709159, "energy": 60794.30597898677, "forces": 0.2585874302476437, "n_frames": 15}}}
+{"epoch": 24, "step": 314526, "train_s": 5894.602258443832, "frames_per_s": 253.60659370334758, "valid_loss": 17.628076299511154, "improved": true, "lr": 0.0007689387421123683, "valid": {"all": {"dipole": 0.18880400579767237, "polar_diag": 0.022572470049971153, "polar_offdiag": 0.014143045048691658, "energy": 54495.53305225668, "forces": 0.27819564295339877, "n_frames": 20000}, "dimers": {"dipole": 0.12067940510343025, "polar_diag": 0.006736695726768797, "polar_offdiag": 0.004922960280777384, "energy": 24677.726196568463, "forces": 0.21394642952602677, "n_frames": 3823}, "monomers": {"dipole": 0.08450784871530807, "polar_diag": 0.004580659544427108, "polar_offdiag": 0.0029825090988448355, "energy": 18199.531916534346, "forces": 0.20706572324725786, "n_frames": 210}, "pubchem": {"dipole": 0.1919700272329768, "polar_diag": 0.025597387975223967, "polar_offdiag": 0.015159415073147404, "energy": 59320.16381267752, "forces": 0.2902616300071212, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.38067704985779127, "polar_diag": 0.05857566536749436, "polar_offdiag": 0.05476084560232752, "energy": 139622.90065634757, "forces": 0.3000141453070534, "n_frames": 156}, "water": {"dipole": 0.21861202403948313, "polar_diag": 0.011487142936490386, "polar_offdiag": 0.00810008519619799, "energy": 62349.608664140214, "forces": 0.3041732810591702, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.238809822344721, "polar_diag": 0.0158776200027711, "polar_offdiag": 0.012236899292647983, "energy": 54224.392115707065, "forces": 0.24682895719430675, "n_frames": 1799}, "dipeptides": {"dipole": 0.3014371736504737, "polar_diag": 0.007327591428767716, "polar_offdiag": 0.0057647391475398, "energy": 29770.452480845594, "forces": 0.23301172075468096, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.30824634940282103, "polar_diag": 0.015231279200582343, "polar_offdiag": 0.009977763665379346, "energy": 60790.27009864873, "forces": 0.2509062894916812, "n_frames": 15}}}
+{"epoch": 25, "step": 327632, "train_s": 5895.108324050903, "frames_per_s": 253.58482284389177, "valid_loss": 17.802556183831445, "improved": false, "lr": 0.0007510572904720902, "valid": {"all": {"dipole": 0.18764213088967144, "polar_diag": 0.022070217327539797, "polar_offdiag": 0.014357119003114222, "energy": 54494.20635310143, "forces": 0.2779455553982846, "n_frames": 20000}, "dimers": {"dipole": 0.11736361043089999, "polar_diag": 0.006529777182870098, "polar_offdiag": 0.0048584736445842994, "energy": 24677.218228748676, "forces": 0.20940783639620475, "n_frames": 3823}, "monomers": {"dipole": 0.08627173312080272, "polar_diag": 0.004330595338938989, "polar_offdiag": 0.002880358043006501, "energy": 18198.95639498778, "forces": 0.20438736174239344, "n_frames": 210}, "pubchem": {"dipole": 0.19103407615730397, "polar_diag": 0.0248649196892401, "polar_offdiag": 0.015336166959190706, "energy": 59318.80992878265, "forces": 0.287238469411594, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.38218378364979555, "polar_diag": 0.06412510014860703, "polar_offdiag": 0.05744841807365396, "energy": 139620.57555811567, "forces": 0.2985638061210796, "n_frames": 156}, "water": {"dipole": 0.25674400086220966, "polar_diag": 0.009575066359491735, "polar_offdiag": 0.007898415120570466, "energy": 62347.506124944564, "forces": 0.31441033068478824, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.23862150474896018, "polar_diag": 0.01526270825286197, "polar_offdiag": 0.012321842132013676, "energy": 54222.10270871585, "forces": 0.26513175089552965, "n_frames": 1799}, "dipeptides": {"dipole": 0.29501317960119927, "polar_diag": 0.007194203961189781, "polar_offdiag": 0.005650577380197439, "energy": 29768.446464301076, "forces": 0.23063334990775133, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.30036825254653343, "polar_diag": 0.014209187143138197, "polar_offdiag": 0.010032473757135042, "energy": 60787.59227781055, "forces": 0.2521232131561992, "n_frames": 15}}}
+{"epoch": 26, "step": 340738, "train_s": 5895.13011264801, "frames_per_s": 253.58388558594635, "valid_loss": 17.59069754885531, "improved": true, "lr": 0.0007327387575060129, "valid": {"all": {"dipole": 0.18576001511146437, "polar_diag": 0.022125862495781103, "polar_offdiag": 0.014209818251003908, "energy": 54495.520854851915, "forces": 0.27758728036026015, "n_frames": 20000}, "dimers": {"dipole": 0.11930999825980061, "polar_diag": 0.006641135099050614, "polar_offdiag": 0.004864929036235891, "energy": 24677.67570362742, "forces": 0.21141186026145142, "n_frames": 3823}, "monomers": {"dipole": 0.08509520007044273, "polar_diag": 0.004428179989751812, "polar_offdiag": 0.002808126030955644, "energy": 18199.427959612985, "forces": 0.20299107672314368, "n_frames": 210}, "pubchem": {"dipole": 0.18787148231164652, "polar_diag": 0.02492465361471122, "polar_offdiag": 0.015224742769245247, "energy": 59320.11929374207, "forces": 0.28474460106315275, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3910168187371645, "polar_diag": 0.06256713220382247, "polar_offdiag": 0.055529130507213, "energy": 139624.08425262675, "forces": 0.2932545513363628, "n_frames": 156}, "water": {"dipole": 0.25027932729356156, "polar_diag": 0.012690645722974084, "polar_offdiag": 0.007769299259493924, "energy": 62351.0058207335, "forces": 0.2909599617520561, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2394365553172705, "polar_diag": 0.015859270105536536, "polar_offdiag": 0.01224100458197395, "energy": 54224.39606265984, "forces": 0.2766164939497258, "n_frames": 1799}, "dipeptides": {"dipole": 0.28751370008941896, "polar_diag": 0.0070149744038840835, "polar_offdiag": 0.005605945277109494, "energy": 29770.4274907095, "forces": 0.22878160592271357, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3029487468867823, "polar_diag": 0.014324622161067458, "polar_offdiag": 0.010126171418072484, "energy": 60791.994981795644, "forces": 0.24841595582176482, "n_frames": 15}}}
+{"epoch": 27, "step": 353843, "train_s": 5894.946793794632, "frames_per_s": 253.59177144289586, "valid_loss": 17.6654375212631, "improved": false, "lr": 0.000714017020072788, "valid": {"all": {"dipole": 0.18361983345624397, "polar_diag": 0.022146636854879963, "polar_offdiag": 0.014108143857424687, "energy": 54494.16370094691, "forces": 0.27611876751299413, "n_frames": 20000}, "dimers": {"dipole": 0.11901944606918004, "polar_diag": 0.006581041206915752, "polar_offdiag": 0.004832074184283712, "energy": 24677.178556466224, "forces": 0.2067666505431745, "n_frames": 3823}, "monomers": {"dipole": 0.08487951827909378, "polar_diag": 0.004528413805236139, "polar_offdiag": 0.002773093450191371, "energy": 18198.984260509864, "forces": 0.20049034843688834, "n_frames": 210}, "pubchem": {"dipole": 0.18594060121764133, "polar_diag": 0.024905982265604542, "polar_offdiag": 0.015047457733328938, "energy": 59318.857181585656, "forces": 0.283784972830658, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.38440245741751117, "polar_diag": 0.06631944462261558, "polar_offdiag": 0.057024257035728186, "energy": 139618.67280010055, "forces": 0.29239796928119766, "n_frames": 156}, "water": {"dipole": 0.2369700155083231, "polar_diag": 0.009971021906149156, "polar_offdiag": 0.00796393569006784, "energy": 62341.40340324169, "forces": 0.28966117841507655, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.23459016127625307, "polar_diag": 0.015124306707766716, "polar_offdiag": 0.012039818935830688, "energy": 54221.790066550944, "forces": 0.2736955608359111, "n_frames": 1799}, "dipeptides": {"dipole": 0.2833416762770372, "polar_diag": 0.006915502199299368, "polar_offdiag": 0.0055761571814632056, "energy": 29767.95729474968, "forces": 0.2260958054162346, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.29677581915031964, "polar_diag": 0.015060653521600301, "polar_offdiag": 0.010250071408942477, "energy": 60784.07651131449, "forces": 0.25128449928073987, "n_frames": 15}}}
+{"epoch": 28, "step": 366949, "train_s": 5895.303846120834, "frames_per_s": 253.57641251751, "valid_loss": 29.441635683692734, "improved": false, "lr": 0.0006949223461560905, "valid": {"all": {"dipole": 0.18449652113594453, "polar_diag": 0.02543501256209385, "polar_offdiag": 0.018972554002653443, "energy": 54493.9819697992, "forces": 0.2716514853659532, "n_frames": 20000}, "dimers": {"dipole": 0.11998402508031897, "polar_diag": 0.006551500366087177, "polar_offdiag": 0.004757428159068038, "energy": 24677.023410636517, "forces": 0.20602662873800368, "n_frames": 3823}, "monomers": {"dipole": 0.08398452820733995, "polar_diag": 0.004315494747153288, "polar_offdiag": 0.002678961889377697, "energy": 18198.812779697368, "forces": 0.19312614266654132, "n_frames": 210}, "pubchem": {"dipole": 0.18608362453943836, "polar_diag": 0.024004482112299958, "polar_offdiag": 0.014900969552281767, "energy": 59318.68887658513, "forces": 0.2794014757035011, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3735704125239157, "polar_diag": 0.06439215115825377, "polar_offdiag": 0.05628330014082964, "energy": 139618.34031313678, "forces": 0.2905296105068684, "n_frames": 156}, "water": {"dipole": 0.2504402170478722, "polar_diag": 0.01299226068984644, "polar_offdiag": 0.008104574466851266, "energy": 62341.863907237894, "forces": 0.29790971180253023, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2417252151896125, "polar_diag": 0.048249223681477535, "polar_offdiag": 0.04445769672357246, "energy": 54221.41605252968, "forces": 0.26660112420080334, "n_frames": 1799}, "dipeptides": {"dipole": 0.2826034584816003, "polar_diag": 0.006958161145341966, "polar_offdiag": 0.005445727232260369, "energy": 29767.712426145787, "forces": 0.22292991497573508, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.3074520705378301, "polar_diag": 0.013647712821963788, "polar_offdiag": 0.010309755776191051, "energy": 60783.814828181574, "forces": 0.243141473124641, "n_frames": 15}}}
+{"epoch": 29, "step": 380054, "train_s": 5894.721460342407, "frames_per_s": 253.6014653206642, "valid_loss": 17.261381413059674, "improved": true, "lr": 0.0006754920468665659, "valid": {"all": {"dipole": 0.18219383245099016, "polar_diag": 0.022109490576796512, "polar_offdiag": 0.01391508940443307, "energy": 54493.52448763797, "forces": 0.2704621169441875, "n_frames": 20000}, "dimers": {"dipole": 0.12022042550462952, "polar_diag": 0.00663810812231665, "polar_offdiag": 0.004748692879404545, "energy": 24676.979982437537, "forces": 0.20403056706424272, "n_frames": 3823}, "monomers": {"dipole": 0.08511257826654232, "polar_diag": 0.004284582265292513, "polar_offdiag": 0.0027308174105339983, "energy": 18198.693813934377, "forces": 0.19188204111787352, "n_frames": 210}, "pubchem": {"dipole": 0.18384566179048153, "polar_diag": 0.02497057451782816, "polar_offdiag": 0.014827790195479449, "energy": 59318.17386476317, "forces": 0.27785985076992786, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.37561158087952745, "polar_diag": 0.06236686718830562, "polar_offdiag": 0.05616640739147337, "energy": 139618.15752019268, "forces": 0.28616694214469984, "n_frames": 156}, "water": {"dipole": 0.23177740129580943, "polar_diag": 0.009555973609699054, "polar_offdiag": 0.008151222374919664, "energy": 62342.23700097482, "forces": 0.29274037615701043, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.23522932520377457, "polar_diag": 0.015148481298804726, "polar_offdiag": 0.01205208677285372, "energy": 54220.731046319655, "forces": 0.2680704960830064, "n_frames": 1799}, "dipeptides": {"dipole": 0.2809221873018988, "polar_diag": 0.006737909905710175, "polar_offdiag": 0.005479345493211021, "energy": 29767.211169338654, "forces": 0.2226336560295588, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.29245025642888, "polar_diag": 0.01288842550130452, "polar_offdiag": 0.010129088293500007, "energy": 60783.9804860897, "forces": 0.24276386383323953, "n_frames": 15}}}
+{"epoch": 30, "step": 393159, "train_s": 5894.769905328751, "frames_per_s": 253.59938114779206, "valid_loss": 16.90868772549191, "improved": true, "lr": 0.000655758602079004, "valid": {"all": {"dipole": 0.17972260811914725, "polar_diag": 0.021591732564576985, "polar_offdiag": 0.013734826945809431, "energy": 54494.25442312979, "forces": 0.27004533400395747, "n_frames": 20000}, "dimers": {"dipole": 0.11902543169144625, "polar_diag": 0.006748259407055683, "polar_offdiag": 0.004759900538816351, "energy": 24677.1125136428, "forces": 0.2025706148637826, "n_frames": 3823}, "monomers": {"dipole": 0.08468233142685928, "polar_diag": 0.004229820067323548, "polar_offdiag": 0.0027916744551655043, "energy": 18198.86529586784, "forces": 0.1919051329455683, "n_frames": 210}, "pubchem": {"dipole": 0.18136229117088, "polar_diag": 0.02420593128182369, "polar_offdiag": 0.014481235929765673, "energy": 59318.943042585364, "forces": 0.2748750149586894, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3732771817840903, "polar_diag": 0.06295584038684733, "polar_offdiag": 0.0572068835030208, "energy": 139620.22803121037, "forces": 0.28378325402749166, "n_frames": 156}, "water": {"dipole": 0.21475988295176077, "polar_diag": 0.009511228672263252, "polar_offdiag": 0.007967082770634208, "energy": 62344.108302228524, "forces": 0.28165262099309935, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.23266221244085186, "polar_diag": 0.015982360895731115, "polar_offdiag": 0.012528336202555421, "energy": 54221.776629469, "forces": 0.2818650591031386, "n_frames": 1799}, "dipeptides": {"dipole": 0.26626098746593646, "polar_diag": 0.006833624749764291, "polar_offdiag": 0.005455423692637442, "energy": 29767.957013938216, "forces": 0.22140467773041145, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.30788601655223313, "polar_diag": 0.013509521133555975, "polar_offdiag": 0.01035807517647294, "energy": 60786.06661398647, "forces": 0.24526825260192225, "n_frames": 15}}}
+{"epoch": 31, "step": 406263, "train_s": 5894.333190202713, "frames_per_s": 253.61817049717683, "valid_loss": 16.755125568515954, "improved": true, "lr": 0.0006357591482810676, "valid": {"all": {"dipole": 0.1806590719458205, "polar_diag": 0.02152348707695357, "polar_offdiag": 0.013795795811337745, "energy": 54494.36752869053, "forces": 0.26504798317624334, "n_frames": 20000}, "dimers": {"dipole": 0.12086106384093342, "polar_diag": 0.006516929935722517, "polar_offdiag": 0.004705671895803854, "energy": 24677.139817587697, "forces": 0.19883622787227495, "n_frames": 3823}, "monomers": {"dipole": 0.08415652993260053, "polar_diag": 0.004180377267506557, "polar_offdiag": 0.0026401126498794437, "energy": 18198.90923785321, "forces": 0.18554073823131392, "n_frames": 210}, "pubchem": {"dipole": 0.1826988182980787, "polar_diag": 0.02421609942282186, "polar_offdiag": 0.01470193350935701, "energy": 59319.021661838924, "forces": 0.27237413468759863, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3736195764602825, "polar_diag": 0.06381112357279768, "polar_offdiag": 0.056713947573832274, "energy": 139620.36681640943, "forces": 0.2805460990620287, "n_frames": 156}, "water": {"dipole": 0.21448437081523603, "polar_diag": 0.012916229422229836, "polar_offdiag": 0.007978731183083228, "energy": 62344.77585629311, "forces": 0.27639226729582983, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.23009194992932677, "polar_diag": 0.014688137527657826, "polar_offdiag": 0.011521245285183526, "energy": 54222.269642223335, "forces": 0.2627285887902784, "n_frames": 1799}, "dipeptides": {"dipole": 0.2705922193808176, "polar_diag": 0.006770408969897123, "polar_offdiag": 0.005285857115844631, "energy": 29768.57984725588, "forces": 0.21928771622938856, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.2999752899872461, "polar_diag": 0.014406301786330112, "polar_offdiag": 0.010215070892962742, "energy": 60786.5922058475, "forces": 0.2407481559621297, "n_frames": 15}}}
+{"epoch": 32, "step": 419368, "train_s": 5894.7710156440735, "frames_per_s": 253.5993333808342, "valid_loss": 16.61924383489565, "improved": true, "lr": 0.000615525699686259, "valid": {"all": {"dipole": 0.17771559449766175, "polar_diag": 0.021144650596098203, "polar_offdiag": 0.013837841602178508, "energy": 54494.19487074931, "forces": 0.2645946714099885, "n_frames": 20000}, "dimers": {"dipole": 0.1194659800940425, "polar_diag": 0.00665942371751738, "polar_offdiag": 0.004717513507762695, "energy": 24677.04417495459, "forces": 0.1970466187466733, "n_frames": 3823}, "monomers": {"dipole": 0.08449266180895984, "polar_diag": 0.004170905983667639, "polar_offdiag": 0.0025873192713121, "energy": 18198.855650051973, "forces": 0.18421834605646192, "n_frames": 210}, "pubchem": {"dipole": 0.17948317769291186, "polar_diag": 0.023683281270102125, "polar_offdiag": 0.014701012445918732, "energy": 59318.896960368664, "forces": 0.27020789455532274, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.36808449745655153, "polar_diag": 0.06502728960632595, "polar_offdiag": 0.057736001431505576, "energy": 139618.91765141944, "forces": 0.2820302367757091, "n_frames": 156}, "water": {"dipole": 0.22117596887897004, "polar_diag": 0.010122048319782029, "polar_offdiag": 0.007706954992257606, "energy": 62342.79898386707, "forces": 0.28522279740763123, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.22711645207509715, "polar_diag": 0.014625333608459754, "polar_offdiag": 0.011639256674959441, "energy": 54221.85857462164, "forces": 0.2717680076392499, "n_frames": 1799}, "dipeptides": {"dipole": 0.26632033093121504, "polar_diag": 0.006745657878615978, "polar_offdiag": 0.005342207797480185, "energy": 29768.181100645306, "forces": 0.21551512743045662, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.27805614404894474, "polar_diag": 0.013815930287435664, "polar_offdiag": 0.010081384536870335, "energy": 60784.57067381492, "forces": 0.2417100623099975, "n_frames": 15}}}
+{"epoch": 33, "step": 432473, "train_s": 5894.584984540939, "frames_per_s": 253.60733688979482, "valid_loss": 16.64092415845257, "improved": false, "lr": 0.0005950959748588502, "valid": {"all": {"dipole": 0.17661860499157214, "polar_diag": 0.02151007886354841, "polar_offdiag": 0.013651067904996423, "energy": 54493.54911141685, "forces": 0.2622261693068808, "n_frames": 20000}, "dimers": {"dipole": 0.11854130736802161, "polar_diag": 0.006451746962997536, "polar_offdiag": 0.004684958337567788, "energy": 24676.88812193879, "forces": 0.1970717203998194, "n_frames": 3823}, "monomers": {"dipole": 0.08337594713835215, "polar_diag": 0.0043464790238036104, "polar_offdiag": 0.0026362009902503865, "energy": 18198.67559388398, "forces": 0.18568391091543507, "n_frames": 210}, "pubchem": {"dipole": 0.17858100454250217, "polar_diag": 0.02417069680301594, "polar_offdiag": 0.014499132205125624, "energy": 59318.26180029893, "forces": 0.2672011113481995, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3620618575502918, "polar_diag": 0.06499351475989734, "polar_offdiag": 0.05722278964520958, "energy": 139617.16983236696, "forces": 0.2792625827408927, "n_frames": 156}, "water": {"dipole": 0.21675645278755476, "polar_diag": 0.013287758799646693, "polar_offdiag": 0.007706269112400968, "energy": 62340.40260193568, "forces": 0.2832044220915379, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.22571432042864728, "polar_diag": 0.0146494117603905, "polar_offdiag": 0.01136825015111867, "energy": 54220.616576835484, "forces": 0.2716089214383952, "n_frames": 1799}, "dipeptides": {"dipole": 0.2601805250269858, "polar_diag": 0.00685839389013604, "polar_offdiag": 0.005276562398489441, "energy": 29767.0811500879, "forces": 0.21339556700377707, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.2989244226945947, "polar_diag": 0.013234063469353893, "polar_offdiag": 0.010245400766333413, "energy": 60782.11891447462, "forces": 0.2411432772228143, "n_frames": 15}}}
+{"epoch": 34, "step": 445578, "train_s": 5894.739277839661, "frames_per_s": 253.60069878236644, "valid_loss": 16.700642252790516, "improved": false, "lr": 0.0005745061789639294, "valid": {"all": {"dipole": 0.1759995814921777, "polar_diag": 0.021331993534655393, "polar_offdiag": 0.013733792374000763, "energy": 54492.47835327001, "forces": 0.2596570491430791, "n_frames": 20000}, "dimers": {"dipole": 0.11776689423616914, "polar_diag": 0.006355829817735918, "polar_offdiag": 0.004670524808500308, "energy": 24676.54000846619, "forces": 0.19765694508832948, "n_frames": 3823}, "monomers": {"dipole": 0.08152078631932187, "polar_diag": 0.0042068445997741925, "polar_offdiag": 0.0026053335209603, "energy": 18198.22330208037, "forces": 0.18380633775941738, "n_frames": 210}, "pubchem": {"dipole": 0.17742369628456997, "polar_diag": 0.023888293345132615, "polar_offdiag": 0.014571116634083699, "energy": 59317.13247384686, "forces": 0.2655939181445659, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.37094292160274767, "polar_diag": 0.06622399151513707, "polar_offdiag": 0.05807853259463148, "energy": 139615.77253929296, "forces": 0.27636968621437175, "n_frames": 156}, "water": {"dipole": 0.19234370995386438, "polar_diag": 0.008757797987554598, "polar_offdiag": 0.007815847077227623, "energy": 62339.79425237599, "forces": 0.28044498512316324, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.22774883600323068, "polar_diag": 0.014936408999946922, "polar_offdiag": 0.011420145591677762, "energy": 54218.88333822064, "forces": 0.2625916549157377, "n_frames": 1799}, "dipeptides": {"dipole": 0.256678555895092, "polar_diag": 0.006588581422593168, "polar_offdiag": 0.005115076116690885, "energy": 29765.661010840075, "forces": 0.213063125984986, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.2874901101811659, "polar_diag": 0.013305947050921352, "polar_offdiag": 0.010162955550447094, "energy": 60780.44597840109, "forces": 0.23658287725593533, "n_frames": 15}}}
+{"epoch": 35, "step": 458683, "train_s": 5894.5585696697235, "frames_per_s": 253.6084733625373, "valid_loss": 16.679479348591006, "improved": false, "lr": 0.000553792982827872, "valid": {"all": {"dipole": 0.17484793520163497, "polar_diag": 0.021442065873526532, "polar_offdiag": 0.013822391842977776, "energy": 54492.77301038735, "forces": 0.25713982070152425, "n_frames": 20000}, "dimers": {"dipole": 0.11729212200759151, "polar_diag": 0.006559404841648542, "polar_offdiag": 0.004644471959117165, "energy": 24676.580072538007, "forces": 0.1934165942244596, "n_frames": 3823}, "monomers": {"dipole": 0.08422963101508715, "polar_diag": 0.00415258821352435, "polar_offdiag": 0.0025618316493774226, "energy": 18198.286537866297, "forces": 0.1819818737773544, "n_frames": 210}, "pubchem": {"dipole": 0.17608198470700515, "polar_diag": 0.024160795968535535, "polar_offdiag": 0.014766241538787058, "energy": 59317.46049019541, "forces": 0.26410617160405514, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.36959618512303866, "polar_diag": 0.06364856480003178, "polar_offdiag": 0.05595173854750968, "energy": 139615.8067665582, "forces": 0.2732021317347017, "n_frames": 156}, "water": {"dipole": 0.20294429615100731, "polar_diag": 0.009483113732151938, "polar_offdiag": 0.007377845797284681, "energy": 62338.80222507602, "forces": 0.26995649913914005, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.22601503305294168, "polar_diag": 0.014096976469014436, "polar_offdiag": 0.011636546287319261, "energy": 54219.36159583514, "forces": 0.25527791025127766, "n_frames": 1799}, "dipeptides": {"dipole": 0.25863443401868924, "polar_diag": 0.006491093342304876, "polar_offdiag": 0.005119374045226437, "energy": 29766.05585959844, "forces": 0.21241623302882878, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.2949594323592734, "polar_diag": 0.014460923175328379, "polar_offdiag": 0.010209956921921719, "energy": 60780.2629017019, "forces": 0.23143237075432146, "n_frames": 15}}}
+{"epoch": 36, "step": 471789, "train_s": 5895.05188035965, "frames_per_s": 253.5872508570353, "valid_loss": 29.35329143309045, "improved": false, "lr": 0.0005329914856702089, "valid": {"all": {"dipole": 0.17367907015921968, "polar_diag": 0.023928831556948794, "polar_offdiag": 0.01985135816811064, "energy": 54493.51493300464, "forces": 0.254230502945638, "n_frames": 20000}, "dimers": {"dipole": 0.119979728486455, "polar_diag": 0.006350737233962646, "polar_offdiag": 0.004601467891260409, "energy": 24676.741315929852, "forces": 0.19072439412764008, "n_frames": 3823}, "monomers": {"dipole": 0.08285814771162958, "polar_diag": 0.0041985079578099145, "polar_offdiag": 0.0025873832628001588, "energy": 18198.538407036456, "forces": 0.1797513133773089, "n_frames": 210}, "pubchem": {"dipole": 0.1754863503709559, "polar_diag": 0.023470852920507095, "polar_offdiag": 0.014504006028794428, "energy": 59318.27138809783, "forces": 0.26220294480158307, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.36715929277166204, "polar_diag": 0.06188305276713917, "polar_offdiag": 0.05604625320815005, "energy": 139616.30512963477, "forces": 0.2700208971938717, "n_frames": 156}, "water": {"dipole": 0.1938109361393299, "polar_diag": 0.013942423063110988, "polar_offdiag": 0.007553433974680331, "energy": 62337.482235237665, "forces": 0.27900485744972914, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.21949794597614514, "polar_diag": 0.04157935093782332, "polar_offdiag": 0.04950710101329263, "energy": 54220.52597948437, "forces": 0.24650642414632187, "n_frames": 1799}, "dipeptides": {"dipole": 0.24165471808263572, "polar_diag": 0.006558261606469184, "polar_offdiag": 0.00513116671433055, "energy": 29767.02386280798, "forces": 0.21102990551704898, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.28935227175081657, "polar_diag": 0.013014924675700893, "polar_offdiag": 0.010178389448889207, "energy": 60780.65937999247, "forces": 0.23104605521452373, "n_frames": 15}}}
+{"epoch": 37, "step": 484894, "train_s": 5894.704081058502, "frames_per_s": 253.60221301076092, "valid_loss": 15.706557631492615, "improved": true, "lr": 0.0005121418507769704, "valid": {"all": {"dipole": 0.17298770465347726, "polar_diag": 0.020714249079320235, "polar_offdiag": 0.013433203085780424, "energy": 54493.32413653621, "forces": 0.254120461335757, "n_frames": 20000}, "dimers": {"dipole": 0.11651973981377511, "polar_diag": 0.006388039582417909, "polar_offdiag": 0.004609702353453622, "energy": 24676.69761587267, "forces": 0.18991001032648763, "n_frames": 3823}, "monomers": {"dipole": 0.08176127300657918, "polar_diag": 0.004073906450642231, "polar_offdiag": 0.0025596558462481008, "energy": 18198.497679492015, "forces": 0.17832784939288582, "n_frames": 210}, "pubchem": {"dipole": 0.17497655189363884, "polar_diag": 0.02327605521133934, "polar_offdiag": 0.014314152669558924, "energy": 59318.08556738701, "forces": 0.2609049551573564, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3711071813351782, "polar_diag": 0.06180919734672282, "polar_offdiag": 0.056013357873292736, "energy": 139615.63149278166, "forces": 0.26983066969691244, "n_frames": 156}, "water": {"dipole": 0.20811261053587912, "polar_diag": 0.009181230925222893, "polar_offdiag": 0.0074845328786960034, "energy": 62337.99762126284, "forces": 0.27082975615769495, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.22028357473572358, "polar_diag": 0.014248997759731381, "polar_offdiag": 0.010866789558327788, "energy": 54220.17761393757, "forces": 0.25330328404600555, "n_frames": 1799}, "dipeptides": {"dipole": 0.23950297788804314, "polar_diag": 0.006685822276852894, "polar_offdiag": 0.005088938501153128, "energy": 29766.61470486281, "forces": 0.21040618132548056, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.2853723551933542, "polar_diag": 0.013264706185725447, "polar_offdiag": 0.0100010372501848, "energy": 60779.83834134474, "forces": 0.22967805185819343, "n_frames": 15}}}
+{"epoch": 38, "step": 497999, "train_s": 5894.652541875839, "frames_per_s": 253.60443035108543, "valid_loss": 15.293279949447204, "improved": true, "lr": 0.0004912795266136527, "valid": {"all": {"dipole": 0.17163171546328215, "polar_diag": 0.020456225937138396, "polar_offdiag": 0.013189064624718173, "energy": 54493.556978358465, "forces": 0.25146331808617595, "n_frames": 20000}, "dimers": {"dipole": 0.11646150659983572, "polar_diag": 0.006467080772629707, "polar_offdiag": 0.004581736635211047, "energy": 24676.778486968255, "forces": 0.19329810885659868, "n_frames": 3823}, "monomers": {"dipole": 0.08246154725728179, "polar_diag": 0.004074373616253412, "polar_offdiag": 0.002535615550350295, "energy": 18198.57806271583, "forces": 0.17592377249291677, "n_frames": 210}, "pubchem": {"dipole": 0.1727472197824293, "polar_diag": 0.02296820612060099, "polar_offdiag": 0.014004494904384993, "energy": 59318.308161826186, "forces": 0.2606372669153312, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.37095226039254103, "polar_diag": 0.06135030189270075, "polar_offdiag": 0.055905782740948214, "energy": 139616.37696899573, "forces": 0.2679054000326269, "n_frames": 156}, "water": {"dipole": 0.20069155800451766, "polar_diag": 0.008803269248745138, "polar_offdiag": 0.007471491608503658, "energy": 62338.97000844886, "forces": 0.27213562433538063, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.2221065519046576, "polar_diag": 0.014030588771907245, "polar_offdiag": 0.010701146677293895, "energy": 54220.62396738908, "forces": 0.23452818751421547, "n_frames": 1799}, "dipeptides": {"dipole": 0.23814762674445264, "polar_diag": 0.006590184393912229, "polar_offdiag": 0.005054669491587873, "energy": 29767.04969826159, "forces": 0.20771914402429562, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.29498359084963427, "polar_diag": 0.012273309914521842, "polar_offdiag": 0.009802201438412546, "energy": 60780.903667736515, "forces": 0.2292955590192551, "n_frames": 15}}}
+{"epoch": 39, "step": 511104, "train_s": 5894.835253477097, "frames_per_s": 253.59656983089056, "valid_loss": 15.735453273544366, "improved": false, "lr": 0.00047044159146025777, "valid": {"all": {"dipole": 0.16952592262857225, "polar_diag": 0.02089898687241086, "polar_offdiag": 0.013436347058020992, "energy": 54493.39473314541, "forces": 0.2506139657672127, "n_frames": 20000}, "dimers": {"dipole": 0.11464729200244564, "polar_diag": 0.006244049482566676, "polar_offdiag": 0.004534816885033303, "energy": 24676.72808435091, "forces": 0.18975395582166735, "n_frames": 3823}, "monomers": {"dipole": 0.08066440216993417, "polar_diag": 0.003981048594636027, "polar_offdiag": 0.0025636473964244567, "energy": 18198.512684387413, "forces": 0.17833897908800242, "n_frames": 210}, "pubchem": {"dipole": 0.1707098087027759, "polar_diag": 0.023605773791609833, "polar_offdiag": 0.014338266431935797, "energy": 59318.10222111816, "forces": 0.258293931525042, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.3731190357360444, "polar_diag": 0.06089540363471605, "polar_offdiag": 0.055946513661108636, "energy": 139617.1280830323, "forces": 0.26666549787941046, "n_frames": 156}, "water": {"dipole": 0.19580540902422272, "polar_diag": 0.009010474443283244, "polar_offdiag": 0.007525797160690359, "energy": 62341.2948763269, "forces": 0.26330795431752946, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.21971371359124703, "polar_diag": 0.013574417756417932, "polar_offdiag": 0.010771167410760108, "energy": 54220.40012974939, "forces": 0.24328326012360377, "n_frames": 1799}, "dipeptides": {"dipole": 0.22632555740383167, "polar_diag": 0.006632847599230013, "polar_offdiag": 0.004969749412212962, "energy": 29766.978931530895, "forces": 0.2069894775941092, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.2862481380663067, "polar_diag": 0.012871572494125448, "polar_offdiag": 0.009953166178250995, "energy": 60782.0706195503, "forces": 0.23055194052904027, "n_frames": 15}}}
+{"epoch": 40, "step": 524210, "train_s": 5895.292354822159, "frames_per_s": 253.57690679703305, "valid_loss": 22.249424601765885, "improved": false, "lr": 0.0004496634646784514, "valid": {"all": {"dipole": 0.249039415454763, "polar_diag": 0.02151462503711028, "polar_offdiag": 0.01711252458721437, "energy": 54493.082943184636, "forces": 0.24794732981621323, "n_frames": 20000}, "dimers": {"dipole": 0.11435676791007066, "polar_diag": 0.006273683988713745, "polar_offdiag": 0.004552196434703613, "energy": 24676.713468820886, "forces": 0.18652370255405967, "n_frames": 3823}, "monomers": {"dipole": 0.08266134436565588, "polar_diag": 0.00391694281901943, "polar_offdiag": 0.0025584238128359446, "energy": 18198.44837760574, "forces": 0.1735432918182832, "n_frames": 210}, "pubchem": {"dipole": 0.16914573919799417, "polar_diag": 0.02329659664449128, "polar_offdiag": 0.014206919643877537, "energy": 59317.782610584785, "forces": 0.25683134244642875, "n_frames": 13745}, "solvated_pubchem": {"dipole": 0.36815279595924644, "polar_diag": 0.06061100022490615, "polar_offdiag": 0.05599361320157704, "energy": 139616.51613414474, "forces": 0.2637380767189959, "n_frames": 156}, "water": {"dipole": 0.1738900594250179, "polar_diag": 0.008935259744436718, "polar_offdiag": 0.0072616544627371665, "energy": 62338.254579351196, "forces": 0.25670016282311575, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.6501754376919651, "polar_diag": 0.024255474789363463, "polar_offdiag": 0.037316709574322364, "energy": 54219.81045455274, "forces": 0.23395307411342914, "n_frames": 1799}, "dipeptides": {"dipole": 0.22737974115665865, "polar_diag": 0.006288989534042216, "polar_offdiag": 0.004880904064779746, "energy": 29766.400716106687, "forces": 0.20692823940651112, "n_frames": 245}, "solvated_amino_acid": {"dipole": 0.2856725283792521, "polar_diag": 0.012381207903345879, "polar_offdiag": 0.00981751260364184, "energy": 60780.74586358194, "forces": 0.2253798413302477, "n_frames": 15}}}

synced/mmml_new_ckpts/spicea_full_v1_q10/split.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea8314ce7dee825403ee4f051b5fb6d001ab484da39d3d933507922aa249d2b2
+size 13328762

synced/mmml_new_ckpts/spicea_full_v1_q10_energy/code_snapshot/BASE

@@ -0,0 +1 @@
+6f85f1a8400f1895d3d163586452d6d48feb32e9

synced/mmml_new_ckpts/spicea_full_v1_q10_energy/code_snapshot/tracked.diff

@@ -0,0 +1,50 @@
+diff --git a/mmml/models/efield/training.py b/mmml/models/efield/training.py
+index 73c40d093..e74a3e80f 100644
+--- a/mmml/models/efield/training.py
++++ b/mmml/models/efield/training.py
+@@ -257,6 +257,9 @@ class EFieldPhysNet(nn.Module):
+     # -0.278 e, too shallow for O/N in organic molecules (MBIS ~ -0.5..-0.9 e);
+     # "linear" leaves them unbounded.
+     charge_activation: str = "silu"
++    # atomic_dipoles=False drops the per-atom dipole head, so the molecular
++    # dipole is the charge term Σ q_i (r_i - c) alone.
++    atomic_dipoles: bool = True
+ 
+     def setup(self):
+         if self.zbl:
+@@ -365,7 +368,7 @@ class EFieldPhysNet(nn.Module):
+         real_atom = (atomic_numbers_flat > 0).astype(atomic_charges.dtype)  # (B*N,)
+         atomic_charges = atomic_charges * real_atom
+ 
+-        if self.max_degree > 0:
++        if self.max_degree > 0 and self.atomic_dipoles:
+             # if max degree > 0
+             # Predict atomic dipoles (3D vector per atom)
+             # Use original x_orig and change max_degree to 1
+diff --git a/scripts/spice_alpha/train_full_packed.py b/scripts/spice_alpha/train_full_packed.py
+index dbaf35e55..ccb0439ed 100644
+--- a/scripts/spice_alpha/train_full_packed.py
++++ b/scripts/spice_alpha/train_full_packed.py
+@@ -50,6 +50,10 @@ def parse_args():
+     ap.add_argument("--cutoff", type=float, default=6.0)
+     ap.add_argument("--gradient-checkpoint", action="store_true")
+     ap.add_argument("--charge-activation", choices=("silu", "linear"), default="silu")
++    ap.add_argument("--no-pseudotensors", dest="pseudotensors", action="store_false",
++                    help="even-parity features only (e3x include_pseudotensors=False)")
++    ap.add_argument("--no-atomic-dipoles", dest="atomic_dipoles", action="store_false",
++                    help="molecular dipole from atomic charges only (no per-atom dipole head)")
+     # loss weights (0.5·squared error per component, as the padded trainer)
+     ap.add_argument("--energy-weight", type=float, default=0.0)
+     ap.add_argument("--forces-weight", type=float, default=1.0)
+@@ -103,9 +107,9 @@ def main():
+                     coulomb_cutoff=args.coulomb_cutoff, max_coulomb_edges=args.max_coulomb_edges)
+     model = EFieldPhysNet(features=args.features, max_degree=args.max_degree,
+                           num_iterations=args.num_iterations, num_basis_functions=args.num_basis_functions,
+-                          cutoff=args.cutoff, max_atomic_number=55, include_pseudotensors=True,
++                          cutoff=args.cutoff, max_atomic_number=55, include_pseudotensors=args.pseudotensors,
+                           field_scale=0.001, zbl=False, electrostatics_damping_sigma=4.0, packed=True,
+-                          charge_activation=args.charge_activation)
++                          charge_activation=args.charge_activation, atomic_dipoles=args.atomic_dipoles)
+     M = spec.max_molecules
+     first = {k: jnp.asarray(v) for k, v in next(iter_packed_batches(data, train_idx[:M], spec)).items()}
+     params = model.init(jax.random.PRNGKey(args.seed), atomic_numbers=first["atomic_numbers"],

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/analysis/final_test/mirror/charges.json

@@ -0,0 +1,82 @@
+{
+  "1": {
+    "n": 1342059,
+    "min": -0.1320561170578003,
+    "p01": -0.043599262833595276,
+    "mean": 0.04930270463228226,
+    "p99": 0.1805747151374817,
+    "max": 0.49791550636291504
+  },
+  "6": {
+    "n": 1122250,
+    "min": -0.24100211262702942,
+    "p01": -0.17140425741672516,
+    "mean": -0.06586859375238419,
+    "p99": 0.048956409096717834,
+    "max": 0.3190489709377289
+  },
+  "7": {
+    "n": 206230,
+    "min": -0.18411977589130402,
+    "p01": -0.13827823102474213,
+    "mean": 0.02388140931725502,
+    "p99": 0.13339363038539886,
+    "max": 0.4179362952709198
+  },
+  "8": {
+    "n": 223130,
+    "min": -0.15175339579582214,
+    "p01": -0.0748543068766594,
+    "mean": 0.02038624696433544,
+    "p99": 0.1433221995830536,
+    "max": 0.25379595160484314
+  },
+  "9": {
+    "n": 27320,
+    "min": -0.057093970477581024,
+    "p01": -0.03521169349551201,
+    "mean": 0.029901163652539253,
+    "p99": 0.13442356884479523,
+    "max": 0.21893195807933807
+  },
+  "15": {
+    "n": 2953,
+    "min": -0.10465652495622635,
+    "p01": -0.09065069258213043,
+    "mean": 0.005114939529448748,
+    "p99": 0.22691640257835388,
+    "max": 0.25866204500198364
+  },
+  "16": {
+    "n": 42016,
+    "min": -0.10789626091718674,
+    "p01": -0.07029428333044052,
+    "mean": 0.03988340497016907,
+    "p99": 0.14949724078178406,
+    "max": 0.25256428122520447
+  },
+  "17": {
+    "n": 19029,
+    "min": -0.080012246966362,
+    "p01": -0.059102676808834076,
+    "mean": 0.005281532648950815,
+    "p99": 0.10509787499904633,
+    "max": 0.1801881194114685
+  },
+  "35": {
+    "n": 5195,
+    "min": -0.07776300609111786,
+    "p01": -0.06481774151325226,
+    "mean": -0.011335941962897778,
+    "p99": 0.08023451268672943,
+    "max": 0.13743822276592255
+  },
+  "53": {
+    "n": 1718,
+    "min": -0.08314467966556549,
+    "p01": -0.07352431863546371,
+    "mean": -0.0203541349619627,
+    "p99": 0.045415472239255905,
+    "max": 0.07276404649019241
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/analysis/final_test/mirror/metrics.json

@@ -0,0 +1,121 @@
+{
+  "meta": {
+    "ckpt_dir": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nodip",
+    "params": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nodip/params-best.json",
+    "units": {
+      "dipole": "e\u00b7\u00c5",
+      "polar": "e\u00b7\u00c5\u00b2/V (= Bohr\u00b3 / 97.17)",
+      "forces": "eV/\u00c5"
+    }
+  },
+  "test": {
+    "all": {
+      "n_frames": 85388,
+      "dipole_rmse": 0.6035969257354736,
+      "dipole_mae": 0.4353146255016327,
+      "dipole_norm_rel": 0.9562778472900391,
+      "polar_diag_rmse": 0.09848610311746597,
+      "polar_diag_mae": 0.052841730415821075,
+      "polar_offdiag_rmse": 0.060549020767211914,
+      "polar_offdiag_mae": 0.03586183860898018,
+      "forces_rmse": 0.8746362924575806,
+      "q_total_abs_max": 1.8279151916503906
+    },
+    "amino_acid_ligand": {
+      "n_frames": 7536,
+      "dipole_rmse": 0.8119066953659058,
+      "dipole_mae": 0.6184759140014648,
+      "dipole_norm_rel": 0.9025138020515442,
+      "polar_diag_rmse": 0.07601182162761688,
+      "polar_diag_mae": 0.04770447686314583,
+      "polar_offdiag_rmse": 0.052490998059511185,
+      "polar_offdiag_mae": 0.03465456888079643,
+      "forces_rmse": 0.5355622172355652,
+      "q_total_abs_max": 1.8279151916503906
+    },
+    "dimers": {
+      "n_frames": 15818,
+      "dipole_rmse": 0.39536383748054504,
+      "dipole_mae": 0.2994936406612396,
+      "dipole_norm_rel": 0.9590898752212524,
+      "polar_diag_rmse": 0.05693868547677994,
+      "polar_diag_mae": 0.03670849651098251,
+      "polar_offdiag_rmse": 0.03917339816689491,
+      "polar_offdiag_mae": 0.02559051848948002,
+      "forces_rmse": 0.6130961775779724,
+      "q_total_abs_max": 1.0731264352798462
+    },
+    "dipeptides": {
+      "n_frames": 1047,
+      "dipole_rmse": 0.6679304242134094,
+      "dipole_mae": 0.5209587812423706,
+      "dipole_norm_rel": 0.9076355695724487,
+      "polar_diag_rmse": 0.15090951323509216,
+      "polar_diag_mae": 0.029823053628206253,
+      "polar_offdiag_rmse": 0.03156902641057968,
+      "polar_offdiag_mae": 0.016108278185129166,
+      "forces_rmse": 0.8588289618492126,
+      "q_total_abs_max": 0.44273093342781067
+    },
+    "monomers": {
+      "n_frames": 900,
+      "dipole_rmse": 0.26858144998550415,
+      "dipole_mae": 0.18808941543102264,
+      "dipole_norm_rel": 0.8541480302810669,
+      "polar_diag_rmse": 0.06338411569595337,
+      "polar_diag_mae": 0.025082264095544815,
+      "polar_offdiag_rmse": 0.03806912153959274,
+      "polar_offdiag_mae": 0.015838896855711937,
+      "forces_rmse": 0.8242253065109253,
+      "q_total_abs_max": 0.3274875581264496
+    },
+    "pubchem": {
+      "n_frames": 59337,
+      "dipole_rmse": 0.594552218914032,
+      "dipole_mae": 0.43883049488067627,
+      "dipole_norm_rel": 0.9674418568611145,
+      "polar_diag_rmse": 0.1080760657787323,
+      "polar_diag_mae": 0.058290813118219376,
+      "polar_offdiag_rmse": 0.06615487486124039,
+      "polar_offdiag_mae": 0.03916580229997635,
+      "forces_rmse": 0.9432830810546875,
+      "q_total_abs_max": 1.7279717922210693
+    },
+    "solvated_amino_acid": {
+      "n_frames": 50,
+      "dipole_rmse": 2.0136020183563232,
+      "dipole_mae": 1.6449061632156372,
+      "dipole_norm_rel": 1.0028889179229736,
+      "polar_diag_rmse": 0.04957396164536476,
+      "polar_diag_mae": 0.03972408175468445,
+      "polar_offdiag_rmse": 0.043301623314619064,
+      "polar_offdiag_mae": 0.03435560315847397,
+      "forces_rmse": 1.192849040031433,
+      "q_total_abs_max": 0.6025660634040833
+    },
+    "solvated_pubchem": {
+      "n_frames": 650,
+      "dipole_rmse": 1.6541876792907715,
+      "dipole_mae": 1.3214715719223022,
+      "dipole_norm_rel": 1.0194073915481567,
+      "polar_diag_rmse": 0.13941265642642975,
+      "polar_diag_mae": 0.0853973999619484,
+      "polar_offdiag_rmse": 0.09480564296245575,
+      "polar_offdiag_mae": 0.058848462998867035,
+      "forces_rmse": 0.9735711812973022,
+      "q_total_abs_max": 1.6463443040847778
+    },
+    "water": {
+      "n_frames": 50,
+      "dipole_rmse": 1.9004148244857788,
+      "dipole_mae": 1.5521562099456787,
+      "dipole_norm_rel": 0.9177337884902954,
+      "polar_diag_rmse": 0.044780947268009186,
+      "polar_diag_mae": 0.0359695665538311,
+      "polar_offdiag_rmse": 0.028382059186697006,
+      "polar_offdiag_mae": 0.023043282330036163,
+      "forces_rmse": 0.7949928641319275,
+      "q_total_abs_max": 0.4605226516723633
+    }
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/analysis/final_test/mirror/preds_test.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5dc03f090db81177ee7935e31ce15176de2d9cc173068188435c22e26f92a19
+size 74958628

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/analysis/final_test/orig/charges.json

@@ -0,0 +1,82 @@
+{
+  "1": {
+    "n": 1342059,
+    "min": -0.13531559705734253,
+    "p01": -0.043455787003040314,
+    "mean": 0.04928123578429222,
+    "p99": 0.18063850700855255,
+    "max": 0.4950897693634033
+  },
+  "6": {
+    "n": 1122250,
+    "min": -0.24100886285305023,
+    "p01": -0.17137736082077026,
+    "mean": -0.06587418913841248,
+    "p99": 0.04899372532963753,
+    "max": 0.30331021547317505
+  },
+  "7": {
+    "n": 206230,
+    "min": -0.1871456801891327,
+    "p01": -0.13851217925548553,
+    "mean": 0.023889170959591866,
+    "p99": 0.13296440243721008,
+    "max": 0.4202997088432312
+  },
+  "8": {
+    "n": 223130,
+    "min": -0.14306087791919708,
+    "p01": -0.0747561901807785,
+    "mean": 0.02037656120955944,
+    "p99": 0.14309921860694885,
+    "max": 0.26203954219818115
+  },
+  "9": {
+    "n": 27320,
+    "min": -0.058002591133117676,
+    "p01": -0.03537638112902641,
+    "mean": 0.029876677319407463,
+    "p99": 0.1345405876636505,
+    "max": 0.21593770384788513
+  },
+  "15": {
+    "n": 2953,
+    "min": -0.10374430567026138,
+    "p01": -0.09098894894123077,
+    "mean": 0.00513516366481781,
+    "p99": 0.22822003066539764,
+    "max": 0.2581087648868561
+  },
+  "16": {
+    "n": 42016,
+    "min": -0.10232876241207123,
+    "p01": -0.07010705024003983,
+    "mean": 0.039956968277692795,
+    "p99": 0.14896708726882935,
+    "max": 0.25862279534339905
+  },
+  "17": {
+    "n": 19029,
+    "min": -0.08014209568500519,
+    "p01": -0.05885012075304985,
+    "mean": 0.005318237468600273,
+    "p99": 0.10423241555690765,
+    "max": 0.17354261875152588
+  },
+  "35": {
+    "n": 5195,
+    "min": -0.081842340528965,
+    "p01": -0.06492592394351959,
+    "mean": -0.011236673220992088,
+    "p99": 0.08058153837919235,
+    "max": 0.137644425034523
+  },
+  "53": {
+    "n": 1718,
+    "min": -0.08080579340457916,
+    "p01": -0.07263004779815674,
+    "mean": -0.020533587783575058,
+    "p99": 0.04624636098742485,
+    "max": 0.07251045852899551
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/analysis/final_test/orig/metrics.json

@@ -0,0 +1,121 @@
+{
+  "meta": {
+    "ckpt_dir": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nodip",
+    "params": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nodip/params-best.json",
+    "units": {
+      "dipole": "e\u00b7\u00c5",
+      "polar": "e\u00b7\u00c5\u00b2/V (= Bohr\u00b3 / 97.17)",
+      "forces": "eV/\u00c5"
+    }
+  },
+  "test": {
+    "all": {
+      "n_frames": 85388,
+      "dipole_rmse": 0.6033908724784851,
+      "dipole_mae": 0.43508997559547424,
+      "dipole_norm_rel": 0.9571672677993774,
+      "polar_diag_rmse": 0.09845484048128128,
+      "polar_diag_mae": 0.05283141881227493,
+      "polar_offdiag_rmse": 0.06056922301650047,
+      "polar_offdiag_mae": 0.03586811199784279,
+      "forces_rmse": 0.87447190284729,
+      "q_total_abs_max": 1.865828037261963
+    },
+    "amino_acid_ligand": {
+      "n_frames": 7536,
+      "dipole_rmse": 0.8084271550178528,
+      "dipole_mae": 0.6152796149253845,
+      "dipole_norm_rel": 0.901006817817688,
+      "polar_diag_rmse": 0.07600891590118408,
+      "polar_diag_mae": 0.047566574066877365,
+      "polar_offdiag_rmse": 0.0522821769118309,
+      "polar_offdiag_mae": 0.034430768340826035,
+      "forces_rmse": 0.5355926752090454,
+      "q_total_abs_max": 1.865828037261963
+    },
+    "dimers": {
+      "n_frames": 15818,
+      "dipole_rmse": 0.39490532875061035,
+      "dipole_mae": 0.299235999584198,
+      "dipole_norm_rel": 0.9583037495613098,
+      "polar_diag_rmse": 0.056793007999658585,
+      "polar_diag_mae": 0.036607906222343445,
+      "polar_offdiag_rmse": 0.03921135142445564,
+      "polar_offdiag_mae": 0.025676248595118523,
+      "forces_rmse": 0.6121159791946411,
+      "q_total_abs_max": 1.0701507329940796
+    },
+    "dipeptides": {
+      "n_frames": 1047,
+      "dipole_rmse": 0.6740750074386597,
+      "dipole_mae": 0.5250363945960999,
+      "dipole_norm_rel": 0.9056898951530457,
+      "polar_diag_rmse": 0.15087242424488068,
+      "polar_diag_mae": 0.02970162406563759,
+      "polar_offdiag_rmse": 0.031287722289562225,
+      "polar_offdiag_mae": 0.015963228419423103,
+      "forces_rmse": 0.8570560216903687,
+      "q_total_abs_max": 0.45194211602211
+    },
+    "monomers": {
+      "n_frames": 900,
+      "dipole_rmse": 0.2684917449951172,
+      "dipole_mae": 0.18809889256954193,
+      "dipole_norm_rel": 0.8511623740196228,
+      "polar_diag_rmse": 0.06321602314710617,
+      "polar_diag_mae": 0.024973422288894653,
+      "polar_offdiag_rmse": 0.03803045675158501,
+      "polar_offdiag_mae": 0.01587272621691227,
+      "forces_rmse": 0.8231726288795471,
+      "q_total_abs_max": 0.3339622914791107
+    },
+    "pubchem": {
+      "n_frames": 59337,
+      "dipole_rmse": 0.5946465134620667,
+      "dipole_mae": 0.43887701630592346,
+      "dipole_norm_rel": 0.9692752957344055,
+      "polar_diag_rmse": 0.10807466506958008,
+      "polar_diag_mae": 0.05832933634519577,
+      "polar_offdiag_rmse": 0.06619955599308014,
+      "polar_offdiag_mae": 0.039186518639326096,
+      "forces_rmse": 0.9432026743888855,
+      "q_total_abs_max": 1.7770122289657593
+    },
+    "solvated_amino_acid": {
+      "n_frames": 50,
+      "dipole_rmse": 2.006716251373291,
+      "dipole_mae": 1.6312594413757324,
+      "dipole_norm_rel": 1.0029261112213135,
+      "polar_diag_rmse": 0.047730185091495514,
+      "polar_diag_mae": 0.03804576396942139,
+      "polar_offdiag_rmse": 0.043788764625787735,
+      "polar_offdiag_mae": 0.03421208634972572,
+      "forces_rmse": 1.1944947242736816,
+      "q_total_abs_max": 0.6157249808311462
+    },
+    "solvated_pubchem": {
+      "n_frames": 650,
+      "dipole_rmse": 1.66090989112854,
+      "dipole_mae": 1.3258017301559448,
+      "dipole_norm_rel": 1.0184335708618164,
+      "polar_diag_rmse": 0.13828536868095398,
+      "polar_diag_mae": 0.08508593589067459,
+      "polar_offdiag_rmse": 0.09475888311862946,
+      "polar_offdiag_mae": 0.0585092157125473,
+      "forces_rmse": 0.9726215600967407,
+      "q_total_abs_max": 1.5431410074234009
+    },
+    "water": {
+      "n_frames": 50,
+      "dipole_rmse": 1.8932085037231445,
+      "dipole_mae": 1.5483278036117554,
+      "dipole_norm_rel": 0.9090250730514526,
+      "polar_diag_rmse": 0.04500819370150566,
+      "polar_diag_mae": 0.035486429929733276,
+      "polar_offdiag_rmse": 0.028629695996642113,
+      "polar_offdiag_mae": 0.02275792695581913,
+      "forces_rmse": 0.7936481833457947,
+      "q_total_abs_max": 0.3936706781387329
+    }
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/analysis/final_test/orig/preds_test.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:451f40b8728543b34d3e81f8a3a0175557b5592c2fa3540152ca7fe40172029f
+size 74946558

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/code_snapshot/BASE

@@ -0,0 +1 @@
+6f85f1a8400f1895d3d163586452d6d48feb32e9

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/code_snapshot/tracked.diff

@@ -0,0 +1,45 @@
+diff --git a/mmml/models/efield/training.py b/mmml/models/efield/training.py
+index 73c40d093..e74a3e80f 100644
+--- a/mmml/models/efield/training.py
++++ b/mmml/models/efield/training.py
+@@ -257,6 +257,9 @@ class EFieldPhysNet(nn.Module):
+     # -0.278 e, too shallow for O/N in organic molecules (MBIS ~ -0.5..-0.9 e);
+     # "linear" leaves them unbounded.
+     charge_activation: str = "silu"
++    # atomic_dipoles=False drops the per-atom dipole head, so the molecular
++    # dipole is the charge term Σ q_i (r_i - c) alone.
++    atomic_dipoles: bool = True
+ 
+     def setup(self):
+         if self.zbl:
+@@ -365,7 +368,7 @@ class EFieldPhysNet(nn.Module):
+         real_atom = (atomic_numbers_flat > 0).astype(atomic_charges.dtype)  # (B*N,)
+         atomic_charges = atomic_charges * real_atom
+ 
+-        if self.max_degree > 0:
++        if self.max_degree > 0 and self.atomic_dipoles:
+             # if max degree > 0
+             # Predict atomic dipoles (3D vector per atom)
+             # Use original x_orig and change max_degree to 1
+diff --git a/scripts/spice_alpha/train_full_packed.py b/scripts/spice_alpha/train_full_packed.py
+index dbaf35e55..470e2b645 100644
+--- a/scripts/spice_alpha/train_full_packed.py
++++ b/scripts/spice_alpha/train_full_packed.py
+@@ -50,6 +50,8 @@ def parse_args():
+     ap.add_argument("--cutoff", type=float, default=6.0)
+     ap.add_argument("--gradient-checkpoint", action="store_true")
+     ap.add_argument("--charge-activation", choices=("silu", "linear"), default="silu")
++    ap.add_argument("--no-atomic-dipoles", dest="atomic_dipoles", action="store_false",
++                    help="molecular dipole from atomic charges only (no per-atom dipole head)")
+     # loss weights (0.5·squared error per component, as the padded trainer)
+     ap.add_argument("--energy-weight", type=float, default=0.0)
+     ap.add_argument("--forces-weight", type=float, default=1.0)
+@@ -105,7 +107,7 @@ def main():
+                           num_iterations=args.num_iterations, num_basis_functions=args.num_basis_functions,
+                           cutoff=args.cutoff, max_atomic_number=55, include_pseudotensors=True,
+                           field_scale=0.001, zbl=False, electrostatics_damping_sigma=4.0, packed=True,
+-                          charge_activation=args.charge_activation)
++                          charge_activation=args.charge_activation, atomic_dipoles=args.atomic_dipoles)
+     M = spec.max_molecules
+     first = {k: jnp.asarray(v) for k, v in next(iter_packed_batches(data, train_idx[:M], spec)).items()}
+     params = model.init(jax.random.PRNGKey(args.seed), atomic_numbers=first["atomic_numbers"],

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/config.json

@@ -0,0 +1,35 @@
+{
+  "ragged_dir": "/scicore/home/meuwly/boitti0000/data/spicealpha/ragged",
+  "out_dir": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nodip",
+  "subsets": null,
+  "max_train_frames": 0,
+  "max_valid_frames": 20000,
+  "epochs": 60,
+  "max_steps": 0,
+  "lr": 0.001,
+  "warmup_steps": 1000,
+  "clip_norm": 10.0,
+  "ema_decay": 0.999,
+  "seed": 0,
+  "restart": null,
+  "max_molecules": 256,
+  "max_atoms": 4096,
+  "max_edges": 98304,
+  "coulomb_cutoff": null,
+  "max_coulomb_edges": 0,
+  "features": 64,
+  "max_degree": 2,
+  "num_iterations": 3,
+  "num_basis_functions": 32,
+  "cutoff": 5.0,
+  "gradient_checkpoint": false,
+  "charge_activation": "silu",
+  "pseudotensors": true,
+  "atomic_dipoles": false,
+  "energy_weight": 0.0,
+  "forces_weight": 10.0,
+  "dipole_weight": 10.0,
+  "polar_weight": 10.0,
+  "charge_weight": 10.0,
+  "log_every": 500
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/gpu_usage.csv

@@ -0,0 +1,247 @@
+2026/10/04 11:28:58.492, NVIDIA H200, 117 MiB, 0 %
+2026/10/04 11:29:28.494, NVIDIA H200, 2793 MiB, 0 %
+2026/10/04 11:29:58.494, NVIDIA H200, 10987 MiB, 0 %
+2026/10/04 11:30:28.495, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:30:58.495, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:31:28.496, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:31:58.497, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:32:28.498, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:32:58.499, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:33:28.500, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:33:58.501, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:34:28.502, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:34:58.503, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:35:28.504, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:35:58.505, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:36:28.506, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:36:58.507, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:37:28.509, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:37:58.510, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:38:28.511, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:38:58.512, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:39:28.513, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:39:58.514, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:40:28.515, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:40:58.516, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:41:28.517, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:41:58.518, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:42:28.519, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:42:58.520, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:43:28.520, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:43:58.521, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:44:28.522, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:44:58.523, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:45:28.524, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:45:58.525, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:46:28.526, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:46:58.527, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:47:28.528, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:47:58.529, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:48:28.530, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:48:58.531, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:49:28.532, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:49:58.533, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:50:28.534, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:50:58.535, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:51:28.536, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:51:58.537, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:52:28.537, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:52:58.538, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:53:28.539, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:53:58.539, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:54:28.540, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:54:58.541, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:55:28.542, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:55:58.543, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:56:28.544, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:56:58.545, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:57:28.545, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:57:58.546, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:58:28.546, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:58:58.547, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:59:28.548, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 11:59:58.549, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:00:28.551, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:00:58.551, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:01:28.552, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:01:58.553, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:02:28.554, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:02:58.556, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:03:28.556, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:03:58.557, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:04:28.558, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:04:58.559, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:05:28.562, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:05:58.563, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:06:28.564, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:06:58.567, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:07:28.568, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:07:58.569, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:08:28.570, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:08:58.571, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:09:28.572, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:09:58.573, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:10:28.574, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:10:58.575, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:11:28.576, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:11:58.577, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:12:28.578, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:12:58.579, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:13:28.580, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:13:58.581, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:14:28.582, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:14:58.582, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:15:28.583, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:15:58.584, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:16:28.585, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:16:58.586, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:17:28.587, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:17:58.588, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:18:28.589, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:18:58.590, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:19:28.591, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:19:58.592, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:20:28.593, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:20:58.594, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:21:28.595, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:21:58.596, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:22:28.597, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:22:58.598, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:23:28.599, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:23:58.600, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:24:28.601, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:24:58.602, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:25:28.603, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:25:58.604, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:26:28.604, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:26:58.605, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:27:28.606, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:27:58.607, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:28:28.607, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:28:58.608, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:29:28.608, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:29:58.609, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:30:28.610, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:30:58.611, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:31:28.612, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:31:58.613, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:32:28.614, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:32:58.615, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:33:28.616, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:33:58.617, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:34:28.618, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:34:58.619, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:35:28.620, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:35:58.621, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:36:28.622, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:36:58.623, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:37:28.624, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:37:58.625, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:38:28.626, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:38:58.627, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:39:28.628, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:39:58.629, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:40:28.630, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:40:58.631, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:41:28.631, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:41:58.632, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:42:28.633, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:42:58.635, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:43:28.636, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:43:58.637, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:44:28.638, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:44:58.639, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:45:28.640, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:45:58.641, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:46:28.642, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:46:58.643, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:47:28.644, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:47:58.645, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:48:28.645, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:48:58.646, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:49:28.647, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:49:58.648, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:50:28.649, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:50:58.650, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:51:28.651, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:51:58.651, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:52:28.652, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:52:58.653, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:53:28.654, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:53:58.655, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:54:28.656, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:54:58.657, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:55:28.657, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:55:58.658, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:56:28.659, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:56:58.660, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:57:28.661, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:57:58.662, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:58:28.663, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:58:58.664, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:59:28.665, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 12:59:58.666, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:00:28.667, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:00:58.668, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:01:28.669, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:01:58.670, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:02:28.671, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:02:58.672, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:03:28.673, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:03:58.674, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:04:28.675, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:04:58.676, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:05:28.677, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:05:58.678, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:06:28.679, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:06:58.680, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:07:28.681, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:07:58.682, NVIDIA H200, 76537 MiB, 100 %
+2026/10/04 13:08:28.683, NVIDIA H200, 76539 MiB, 93 %
+2026/10/04 13:08:58.684, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:09:28.685, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:09:58.686, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:10:28.687, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:10:58.688, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:11:28.689, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:11:58.690, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:12:28.691, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:12:58.692, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:13:28.693, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:13:58.694, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:14:28.695, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:14:58.696, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:15:28.697, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:15:58.698, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:16:28.699, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:16:58.700, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:17:28.700, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:17:58.701, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:18:28.702, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:18:58.704, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:19:28.705, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:19:58.706, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:20:28.707, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:20:58.724, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:21:28.725, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:21:58.726, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:22:28.727, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:22:58.728, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:23:28.729, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:23:58.730, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:24:28.730, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:24:58.731, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:25:28.732, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:25:58.733, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:26:28.733, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:26:58.734, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:27:28.734, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:27:58.735, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:28:28.736, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:28:58.737, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:29:28.738, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:29:58.739, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:30:28.740, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:30:58.741, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:31:28.742, NVIDIA H200, 76539 MiB, 100 %
+2026/10/04 13:31:58.743, NVIDIA H200, 76539 MiB, 100 %

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/history.jsonl

@@ -0,0 +1 @@
+{"epoch": 1, "step": 13105, "train_s": 5904.633398294449, "frames_per_s": 253.17575184799858, "valid_loss": 241.46206990603744, "improved": true, "lr": 0.000999624957330525, "valid": {"all": {"dipole": 0.6092777930660215, "polar_diag": 0.08696065193212175, "polar_offdiag": 0.05511187853615953, "energy": 54503.8131578186, "forces": 0.8634504912912859, "n_frames": 20000}, "dimers": {"dipole": 0.3813481474860928, "polar_diag": 0.047539899093044354, "polar_offdiag": 0.02958196864223642, "energy": 24680.794881533, "forces": 0.5906959973371563, "n_frames": 3823}, "monomers": {"dipole": 0.25559996277669367, "polar_diag": 0.08111296335400166, "polar_offdiag": 0.048762201281338534, "energy": 18202.24316056102, "forces": 0.8174583778050827, "n_frames": 210}, "pubchem": {"dipole": 0.6027022376207001, "polar_diag": 0.09519460315498846, "polar_offdiag": 0.05935521551598298, "energy": 59327.382999966685, "forces": 0.9355167012836874, "n_frames": 13745}, "solvated_pubchem": {"dipole": 1.7101190334327698, "polar_diag": 0.19008446307586238, "polar_offdiag": 0.11587392144983291, "energy": 139662.50186752863, "forces": 0.9295514894436234, "n_frames": 156}, "water": {"dipole": 2.0022562135595314, "polar_diag": 0.04331633274885883, "polar_offdiag": 0.023916904709272345, "energy": 62430.78508007316, "forces": 0.8195645092230542, "n_frames": 7}, "amino_acid_ligand": {"dipole": 0.8168263106483536, "polar_diag": 0.07742354096325564, "polar_offdiag": 0.058989261595601424, "energy": 54242.48894022323, "forces": 0.5148769533235494, "n_frames": 1799}, "dipeptides": {"dipole": 0.7182789669154211, "polar_diag": 0.027939159612169685, "polar_offdiag": 0.019222794609254842, "energy": 29787.29134406696, "forces": 0.8725869136995859, "n_frames": 245}, "solvated_amino_acid": {"dipole": 1.8410631850998347, "polar_diag": 0.051002986680259245, "polar_offdiag": 0.043372492290516686, "energy": 60847.47283495018, "forces": 1.1975492531544336, "n_frames": 15}}}

synced/mmml_new_ckpts/spicea_full_v1_q10_nodip/split.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea8314ce7dee825403ee4f051b5fb6d001ab484da39d3d933507922aa249d2b2
+size 13328762

synced/mmml_new_ckpts/spicea_full_v1_q10_nopt/analysis/final_test/mirror/charges.json

@@ -0,0 +1,82 @@
+{
+  "1": {
+    "n": 1342059,
+    "min": -0.10386063158512115,
+    "p01": -0.036369439214468,
+    "mean": 0.026263896375894547,
+    "p99": 0.12407273799180984,
+    "max": 0.4338514506816864
+  },
+  "6": {
+    "n": 1122250,
+    "min": -0.1531200110912323,
+    "p01": -0.11615389585494995,
+    "mean": -0.028954921290278435,
+    "p99": 0.07237041741609573,
+    "max": 0.20015673339366913
+  },
+  "7": {
+    "n": 206230,
+    "min": -0.14261889457702637,
+    "p01": -0.08254894614219666,
+    "mean": 0.0010452799033373594,
+    "p99": 0.0994144156575203,
+    "max": 0.8763609528541565
+  },
+  "8": {
+    "n": 223130,
+    "min": -0.10527035593986511,
+    "p01": -0.05450461804866791,
+    "mean": 0.003822821192443371,
+    "p99": 0.08837836235761642,
+    "max": 0.2327030450105667
+  },
+  "9": {
+    "n": 27320,
+    "min": -0.05718066543340683,
+    "p01": -0.036252088844776154,
+    "mean": 0.014987216331064701,
+    "p99": 0.09827523678541183,
+    "max": 0.16955795884132385
+  },
+  "15": {
+    "n": 2953,
+    "min": -0.12319440394639969,
+    "p01": -0.10501565039157867,
+    "mean": -0.029971273615956306,
+    "p99": 0.10529305040836334,
+    "max": 0.13597364723682404
+  },
+  "16": {
+    "n": 42016,
+    "min": -0.09439695626497269,
+    "p01": -0.06488649547100067,
+    "mean": 0.016552146524190903,
+    "p99": 0.11056137830018997,
+    "max": 0.2698246240615845
+  },
+  "17": {
+    "n": 19029,
+    "min": -0.0785060003399849,
+    "p01": -0.05161358416080475,
+    "mean": 0.004114324226975441,
+    "p99": 0.08916468918323517,
+    "max": 0.1687195599079132
+  },
+  "35": {
+    "n": 5195,
+    "min": -0.08935115486383438,
+    "p01": -0.07207800447940826,
+    "mean": -0.01002772618085146,
+    "p99": 0.07710643112659454,
+    "max": 0.15862707793712616
+  },
+  "53": {
+    "n": 1718,
+    "min": -0.07942565530538559,
+    "p01": -0.07212900370359421,
+    "mean": -0.0179088544100523,
+    "p99": 0.11112135648727417,
+    "max": 0.11464916169643402
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nopt/analysis/final_test/mirror/metrics.json

@@ -0,0 +1,121 @@
+{
+  "meta": {
+    "ckpt_dir": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nopt",
+    "params": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nopt/params-best.json",
+    "units": {
+      "dipole": "e\u00b7\u00c5",
+      "polar": "e\u00b7\u00c5\u00b2/V (= Bohr\u00b3 / 97.17)",
+      "forces": "eV/\u00c5"
+    }
+  },
+  "test": {
+    "all": {
+      "n_frames": 85388,
+      "dipole_rmse": 0.6307457685470581,
+      "dipole_mae": 0.45440584421157837,
+      "dipole_norm_rel": 0.9716783761978149,
+      "polar_diag_rmse": 0.10671302676200867,
+      "polar_diag_mae": 0.05691656097769737,
+      "polar_offdiag_rmse": 0.0645015612244606,
+      "polar_offdiag_mae": 0.038458552211523056,
+      "forces_rmse": 0.9499576091766357,
+      "q_total_abs_max": 1.7279998064041138
+    },
+    "amino_acid_ligand": {
+      "n_frames": 7536,
+      "dipole_rmse": 0.8604363799095154,
+      "dipole_mae": 0.6547513604164124,
+      "dipole_norm_rel": 0.9592050313949585,
+      "polar_diag_rmse": 0.07995064556598663,
+      "polar_diag_mae": 0.04984345659613609,
+      "polar_offdiag_rmse": 0.055826641619205475,
+      "polar_offdiag_mae": 0.036996420472860336,
+      "forces_rmse": 0.5592979788780212,
+      "q_total_abs_max": 1.7279998064041138
+    },
+    "dimers": {
+      "n_frames": 15818,
+      "dipole_rmse": 0.3888583183288574,
+      "dipole_mae": 0.2884504795074463,
+      "dipole_norm_rel": 0.8872483968734741,
+      "polar_diag_rmse": 0.062348492443561554,
+      "polar_diag_mae": 0.039360206574201584,
+      "polar_offdiag_rmse": 0.04404578357934952,
+      "polar_offdiag_mae": 0.027735741809010506,
+      "forces_rmse": 0.6578519940376282,
+      "q_total_abs_max": 1.1021291017532349
+    },
+    "dipeptides": {
+      "n_frames": 1047,
+      "dipole_rmse": 0.684469997882843,
+      "dipole_mae": 0.5401363372802734,
+      "dipole_norm_rel": 0.9481424689292908,
+      "polar_diag_rmse": 0.15142571926116943,
+      "polar_diag_mae": 0.029894521459937096,
+      "polar_offdiag_rmse": 0.03207430616021156,
+      "polar_offdiag_mae": 0.016801731660962105,
+      "forces_rmse": 0.9617542624473572,
+      "q_total_abs_max": 0.7300765514373779
+    },
+    "monomers": {
+      "n_frames": 900,
+      "dipole_rmse": 0.27214550971984863,
+      "dipole_mae": 0.19655025005340576,
+      "dipole_norm_rel": 0.9123477935791016,
+      "polar_diag_rmse": 0.07091070711612701,
+      "polar_diag_mae": 0.028637971729040146,
+      "polar_offdiag_rmse": 0.04200860485434532,
+      "polar_offdiag_mae": 0.017960598692297935,
+      "forces_rmse": 0.8862960934638977,
+      "q_total_abs_max": 0.29953330755233765
+    },
+    "pubchem": {
+      "n_frames": 59337,
+      "dipole_rmse": 0.6268473267555237,
+      "dipole_mae": 0.4643905758857727,
+      "dipole_norm_rel": 1.0197888612747192,
+      "polar_diag_rmse": 0.11746004968881607,
+      "polar_diag_mae": 0.0630553737282753,
+      "polar_offdiag_rmse": 0.07008269429206848,
+      "polar_offdiag_mae": 0.041924092918634415,
+      "forces_rmse": 1.0269593000411987,
+      "q_total_abs_max": 1.4139212369918823
+    },
+    "solvated_amino_acid": {
+      "n_frames": 50,
+      "dipole_rmse": 1.8252876996994019,
+      "dipole_mae": 1.4527559280395508,
+      "dipole_norm_rel": 0.9116533994674683,
+      "polar_diag_rmse": 0.06331156194210052,
+      "polar_diag_mae": 0.050802942365407944,
+      "polar_offdiag_rmse": 0.04911947622895241,
+      "polar_offdiag_mae": 0.03913164511322975,
+      "forces_rmse": 1.2779628038406372,
+      "q_total_abs_max": 0.5964446663856506
+    },
+    "solvated_pubchem": {
+      "n_frames": 650,
+      "dipole_rmse": 1.6514936685562134,
+      "dipole_mae": 1.3133891820907593,
+      "dipole_norm_rel": 1.0094935894012451,
+      "polar_diag_rmse": 0.15260657668113708,
+      "polar_diag_mae": 0.08962026983499527,
+      "polar_offdiag_rmse": 0.10220740735530853,
+      "polar_offdiag_mae": 0.06394781172275543,
+      "forces_rmse": 1.051700472831726,
+      "q_total_abs_max": 1.355889916419983
+    },
+    "water": {
+      "n_frames": 50,
+      "dipole_rmse": 1.9355826377868652,
+      "dipole_mae": 1.5917577743530273,
+      "dipole_norm_rel": 0.9242793917655945,
+      "polar_diag_rmse": 0.05900231748819351,
+      "polar_diag_mae": 0.04775698482990265,
+      "polar_offdiag_rmse": 0.035669535398483276,
+      "polar_offdiag_mae": 0.02882237732410431,
+      "forces_rmse": 0.94515460729599,
+      "q_total_abs_max": 1.020745873451233
+    }
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nopt/analysis/final_test/mirror/preds_test.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6cedb96f03fdafbe87a223148c663f9f47a703c57a8ebf79a132f1829875688a
+size 74933439

synced/mmml_new_ckpts/spicea_full_v1_q10_nopt/analysis/final_test/orig/charges.json

@@ -0,0 +1,82 @@
+{
+  "1": {
+    "n": 1342059,
+    "min": -0.10386180132627487,
+    "p01": -0.03636821731925011,
+    "mean": 0.026263894513249397,
+    "p99": 0.12406355887651443,
+    "max": 0.4339938461780548
+  },
+  "6": {
+    "n": 1122250,
+    "min": -0.15311837196350098,
+    "p01": -0.11615805327892303,
+    "mean": -0.028954921290278435,
+    "p99": 0.07236950844526291,
+    "max": 0.2001829892396927
+  },
+  "7": {
+    "n": 206230,
+    "min": -0.14261962473392487,
+    "p01": -0.08255037665367126,
+    "mean": 0.0010453143622726202,
+    "p99": 0.0994187518954277,
+    "max": 0.8763609528541565
+  },
+  "8": {
+    "n": 223130,
+    "min": -0.10526727885007858,
+    "p01": -0.05450630560517311,
+    "mean": 0.003822829807177186,
+    "p99": 0.08835796266794205,
+    "max": 0.23281876742839813
+  },
+  "9": {
+    "n": 27320,
+    "min": -0.05718072131276131,
+    "p01": -0.03625902906060219,
+    "mean": 0.014987101778388023,
+    "p99": 0.09827270358800888,
+    "max": 0.169539675116539
+  },
+  "15": {
+    "n": 2953,
+    "min": -0.12319367378950119,
+    "p01": -0.10501641780138016,
+    "mean": -0.029971327632665634,
+    "p99": 0.1052967831492424,
+    "max": 0.13597123324871063
+  },
+  "16": {
+    "n": 42016,
+    "min": -0.09439682960510254,
+    "p01": -0.06488897651433945,
+    "mean": 0.016552161425352097,
+    "p99": 0.1105625107884407,
+    "max": 0.269808292388916
+  },
+  "17": {
+    "n": 19029,
+    "min": -0.0785060003399849,
+    "p01": -0.051613401621580124,
+    "mean": 0.004114223178476095,
+    "p99": 0.08916782587766647,
+    "max": 0.16873231530189514
+  },
+  "35": {
+    "n": 5195,
+    "min": -0.08935113996267319,
+    "p01": -0.07207728177309036,
+    "mean": -0.010027636773884296,
+    "p99": 0.07710616290569305,
+    "max": 0.15862686932086945
+  },
+  "53": {
+    "n": 1718,
+    "min": -0.07942582666873932,
+    "p01": -0.0721265897154808,
+    "mean": -0.01790817640721798,
+    "p99": 0.11111397296190262,
+    "max": 0.11465036123991013
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nopt/analysis/final_test/orig/metrics.json

@@ -0,0 +1,121 @@
+{
+  "meta": {
+    "ckpt_dir": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nopt",
+    "params": "/scicore/home/meuwly/boitti0000/mmml_new/ckpts/spicea_full_v1_q10_nopt/params-best.json",
+    "units": {
+      "dipole": "e\u00b7\u00c5",
+      "polar": "e\u00b7\u00c5\u00b2/V (= Bohr\u00b3 / 97.17)",
+      "forces": "eV/\u00c5"
+    }
+  },
+  "test": {
+    "all": {
+      "n_frames": 85388,
+      "dipole_rmse": 0.6307451128959656,
+      "dipole_mae": 0.45440566539764404,
+      "dipole_norm_rel": 0.9717649817466736,
+      "polar_diag_rmse": 0.10671290755271912,
+      "polar_diag_mae": 0.05691633000969887,
+      "polar_offdiag_rmse": 0.06450184434652328,
+      "polar_offdiag_mae": 0.0384586937725544,
+      "forces_rmse": 0.9499576687812805,
+      "q_total_abs_max": 1.728079080581665
+    },
+    "amino_acid_ligand": {
+      "n_frames": 7536,
+      "dipole_rmse": 0.8604294061660767,
+      "dipole_mae": 0.6547449827194214,
+      "dipole_norm_rel": 0.9591112732887268,
+      "polar_diag_rmse": 0.07995058596134186,
+      "polar_diag_mae": 0.04984176903963089,
+      "polar_offdiag_rmse": 0.0558244064450264,
+      "polar_offdiag_mae": 0.036994073539972305,
+      "forces_rmse": 0.5592981576919556,
+      "q_total_abs_max": 1.728079080581665
+    },
+    "dimers": {
+      "n_frames": 15818,
+      "dipole_rmse": 0.3888606131076813,
+      "dipole_mae": 0.2884499132633209,
+      "dipole_norm_rel": 0.8872373104095459,
+      "polar_diag_rmse": 0.06234733760356903,
+      "polar_diag_mae": 0.03935999050736427,
+      "polar_offdiag_rmse": 0.04404907673597336,
+      "polar_offdiag_mae": 0.027738364413380623,
+      "forces_rmse": 0.6578519344329834,
+      "q_total_abs_max": 1.1021289825439453
+    },
+    "dipeptides": {
+      "n_frames": 1047,
+      "dipole_rmse": 0.6844816207885742,
+      "dipole_mae": 0.5401483774185181,
+      "dipole_norm_rel": 0.9481378793716431,
+      "polar_diag_rmse": 0.1514286994934082,
+      "polar_diag_mae": 0.029896702617406845,
+      "polar_offdiag_rmse": 0.032070353627204895,
+      "polar_offdiag_mae": 0.0167945995926857,
+      "forces_rmse": 0.9617533087730408,
+      "q_total_abs_max": 0.7300603985786438
+    },
+    "monomers": {
+      "n_frames": 900,
+      "dipole_rmse": 0.27214524149894714,
+      "dipole_mae": 0.1965492069721222,
+      "dipole_norm_rel": 0.9124917984008789,
+      "polar_diag_rmse": 0.07090979814529419,
+      "polar_diag_mae": 0.02863672375679016,
+      "polar_offdiag_rmse": 0.042008835822343826,
+      "polar_offdiag_mae": 0.01796092838048935,
+      "forces_rmse": 0.8862943649291992,
+      "q_total_abs_max": 0.29953333735466003
+    },
+    "pubchem": {
+      "n_frames": 59337,
+      "dipole_rmse": 0.6268470287322998,
+      "dipole_mae": 0.46439099311828613,
+      "dipole_norm_rel": 1.019929051399231,
+      "polar_diag_rmse": 0.11746001243591309,
+      "polar_diag_mae": 0.0630553588271141,
+      "polar_offdiag_rmse": 0.07008280605077744,
+      "polar_offdiag_mae": 0.04192393645644188,
+      "forces_rmse": 1.0269594192504883,
+      "q_total_abs_max": 1.4139673709869385
+    },
+    "solvated_amino_acid": {
+      "n_frames": 50,
+      "dipole_rmse": 1.825270175933838,
+      "dipole_mae": 1.4528310298919678,
+      "dipole_norm_rel": 0.911512017250061,
+      "polar_diag_rmse": 0.06332278251647949,
+      "polar_diag_mae": 0.050809524953365326,
+      "polar_offdiag_rmse": 0.04909960553050041,
+      "polar_offdiag_mae": 0.03911763057112694,
+      "forces_rmse": 1.2779650688171387,
+      "q_total_abs_max": 0.5962857007980347
+    },
+    "solvated_pubchem": {
+      "n_frames": 650,
+      "dipole_rmse": 1.6514972448349,
+      "dipole_mae": 1.3134057521820068,
+      "dipole_norm_rel": 1.009496808052063,
+      "polar_diag_rmse": 0.1526065319776535,
+      "polar_diag_mae": 0.08961500972509384,
+      "polar_offdiag_rmse": 0.1022062823176384,
+      "polar_offdiag_mae": 0.06395739316940308,
+      "forces_rmse": 1.0517008304595947,
+      "q_total_abs_max": 1.355952262878418
+    },
+    "water": {
+      "n_frames": 50,
+      "dipole_rmse": 1.9355113506317139,
+      "dipole_mae": 1.5916461944580078,
+      "dipole_norm_rel": 0.9251198768615723,
+      "polar_diag_rmse": 0.05899323895573616,
+      "polar_diag_mae": 0.047736331820487976,
+      "polar_offdiag_rmse": 0.035664577037096024,
+      "polar_offdiag_mae": 0.028811441734433174,
+      "forces_rmse": 0.9451538920402527,
+      "q_total_abs_max": 1.0207202434539795
+    }
+  }
+}

synced/mmml_new_ckpts/spicea_full_v1_q10_nopt/analysis/final_test/orig/preds_test.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b261dc186dfc3ca0efee8fcd064d8516bdfad63ade9c248429fa5cdbecdfac38
+size 74928525

synced/mmml_new_ckpts/spicea_full_v1_q10_nopt/code_snapshot/BASE

@@ -0,0 +1 @@
+6f85f1a8400f1895d3d163586452d6d48feb32e9