Canis M

1. Overview

Canis M is a molecular model trained on quantum tokens. A quantum token is a quantum-mechanical representation of a molecule, minted once by our engine and read by the model in place of atomic coordinates. It reaches chemical accuracy on 99.6 percent of held-out molecules. Separately, in a controlled comparison on a common learner, the token reaches with 50 labelled molecules what the standard descriptor does not reach with 16,000 (section 5.1).

The model learns the residual a cheap electronic-structure method leaves behind. The tractable physics remains in the cheap calculation; the model supplies only what that calculation cannot reach.

correction  =  E_CASCI(6,6)/6-31G  −  E_MP2

The prediction is added back to the cheap calculation to give a corrected energy. This is delta-learning, and it is what allows a 162,243-parameter network to reach chemical accuracy: the model is never asked to rediscover electronic structure from geometry, because the token already carries it.

Drug-sized molecules

Drug-sized molecules are where descriptors run out. On 40,600 real compounds of 20 to 52 heavy atoms, we ran every arm on the same split with the same learner and changed only the input:

The strongest classical arm scores two molecules in three. The tokens score nine in ten, a 2.97× improvement in error, and closer on 78.6 percent of molecules when compared pair by pair. The ordering holds in every one of the eight size bands, from 20 heavy atoms to 52.

Those labels were minted on NVIDIA GPUs, including an NVIDIA RTX PRO 6000, provided through NVIDIA Brev, with the balance on the AMD Ryzen AI MAX+ 395 workstation.

That model is not this one, and it is not on this page. It works on tokens we mint for your compounds. If your molecules are drug-sized, and if that 65 percent is what your own pipeline is living with, let's talk: section 8.

2. Model properties

Tokens are geometry-dependent: one token describes one 3D conformation, not one molecule.

Tokens are concatenative. Canis M is trained on tokens alone, but appending tokens to an existing descriptor outperformed either representation by itself on three of four test sets. An existing representation is extended rather than displaced.

3. Methods of distribution

The weights are distributed under Apache 2.0: the licence puts no restriction on use, modification or redistribution. Downloading asks you to tell us who you are first.

The encoder that mints tokens is not part of this release. Canis M does not accept a molecule as input; it accepts a token.

Usage

The checkpoint ships with a verification fixture: 64 tokens and the outputs this model produces for them, carried inside the file. So the block below is one copy-paste with one download: no dataset, no key, no contact with us. It confirms that the weights you have compute exactly the function we published.

pip install torch numpy huggingface_hub

import torch, torch.nn as nn
from huggingface_hub import hf_hub_download

config  = hf_hub_download("SiriusQuantum/canis-m", "config.json")   # model spec: input, outputs, units
weights = hf_hub_download("SiriusQuantum/canis-m", "canis-m-v1.pt")

# The checkpoint is a state dict with its shape metadata, not a pickled module,
# so the network is rebuilt from the file.
ckpt  = torch.load(weights, map_location="cpu")
model = nn.Sequential(
    nn.Linear(ckpt["in_dim"], ckpt["hid"]), nn.SiLU(),
    nn.Linear(ckpt["hid"],    ckpt["hid"]), nn.SiLU(),
    nn.Linear(ckpt["hid"],    ckpt["n_out"]),
)
model.load_state_dict(ckpt["state_dict"])
model.eval()

fx    = ckpt["fixture"]
token = fx["token"]                  # (64, 648) float32, already in the published basis

with torch.no_grad():
    out = model(token)

correction     = out[:, 0].numpy()   # Hartree, against MP2. add to your cheap calculation
correction_ite = out[:, 1].numpy()   # the same correction against an imaginary-time baseline
mr_index       = out[:, 2].numpy()   # multireference character

deviation = (out - fx["expected"]).abs().max().item()
print(f"{fx['n']} tokens | max deviation from expected {deviation:.1e} | "
      f"{'OK' if deviation == 0 else 'MISMATCH: do not use this file'}")

Expected output:

64 tokens | max deviation from expected 0.0e+00 | OK

An exact match means the file you downloaded computes the same function, bit for bit, as the one described here. For what the model achieves, see section 5. Those numbers rest on 28,552 held-out molecules, not on these 64.

The checkpoint also carries mae_mHa, within_chem_acc, n_train, targets and units, so a file can be identified without reference to this card. If those disagree with section 2, you have the wrong file, tell us.

Tokens to run it on

The fixture proves the weights are the ones described here. It is not a dataset: it carries tokens and labels but no structures, so there is nothing in it to look a molecule up by.

For molecules, there is a free token pack:

SiriusQuantum/canis-m-token-pack carries 12,000 public GDB-13 molecules at the relaxed geometry, tokens already in the published basis, reference labels included. Enough to concatenate our token onto your own descriptor and measure what it does to your model, in an afternoon, for nothing.

The pack covers 10, 11 and 12 heavy atoms, 4,000 molecules each. Drug-sized molecules are a different model, in section 1. This checkpoint does not serve them, and it will not say so: it has no way to tell that a token came from outside the regime it was trained on, so it answers anyway.

Running it on your own molecules

Tokens for your own molecules are minted by us. Send the list, get the tokens back. See section 8.

Outputs are already in Hartree; do not rescale them. Tokens arrive pre-normalised; do not standardise them again.

Tokens arrive in the published basis, R @ (x − mu)/sd. A token minted or extracted any other way must have that transform applied before it reaches these weights. A raw token does not raise an error; it returns a plausible, wrong number.

4. Training

Reference labels were computed at CASCI(6,6)/6-31G on a single AMD x86-64 workstation (16 cores, 32 threads, 128 GB). The drug-scale labels in section 1 were minted on NVIDIA GPUs, including an NVIDIA RTX PRO 6000, provided through NVIDIA Brev.

1,989,829 geometries over 424,171 distinct molecules. gdb13_100k is a strict subset of gdb13_500k and the torsion shard is 92.2% contained in it; the independent chemistry is in the size and element shards and in QM9.

Canis M was trained on 177,200 molecules from this corpus.

5. Evaluations

Evaluated on 28,552 held-out molecules with scaffold-disjoint splits: no test molecule shares a scaffold with any training molecule. Architecture and training-set size are identical across arms; only the input features change.

Chemical accuracy is 1.6 mHa (1 kcal/mol). The failure rate falls from roughly one molecule in five to one in 250, using fewer input dimensions and a smaller model than the baseline.

5.1 Data efficiency

Same learner, same scaffold-disjoint split, same training-set size at every point; only the input changes. The dotted line joins two measured points: quantum tokens at 50 training molecules, and the standard descriptor at 16,000.

Error in mHa. Given 320 times more labelled molecules, the standard descriptor does not catch up. Against 3D structure alone the same comparison is 1.9–2.9×.

Both sides are measured points; nothing is fitted or extrapolated.

5.2 Effect of model capacity

The token's contribution was measured at three model capacities and increased at every step. A small model is limited by its own capacity; a larger one is limited by its input.

This is a trend across three capacities, not an established property.

5.3 Where the advantage concentrates

Every token carries a difficulty score computed without any expensive calculation. Test molecules sorted into five groups by that score:

In the hardest group the tokens remain within chemical accuracy and the classical descriptor does not.

5.4 Transfer to larger molecules

Trained on smaller molecules only, tested on sizes never seen: the 12-heavy-atom test uses a model trained at 10 and 11, the 13-heavy-atom test one trained at 10, 11 and 12.

A model that has never seen a 13-heavy-atom molecule outperforms the classical descriptor trained on them.

5.5 Reproducing the baselines

Every comparison arm other than ours is built from public components used unmodified: ANI-2x atomic environment vectors from the released TorchANI model, the QM9 dataset, and GDB-13 as the source of the enumerated shards. Verifying what the classical baselines achieve requires nothing from Sirius Quantum.

5.6 Checking the target without an API key

The token is the part of this release that is not free, but the target is. SQMolecular95k carries corr_residual_hartree, which is fci - mp2 on a frontier (6,6) active space at 6-31G, for 94,376 geometries of 6,745 public-domain molecules. That is the same quantity, the same active space, the same basis and the same column name this model emits.

So the classical half of every comparison in section 5 can be reproduced end to end by someone who has never spoken to us: public molecules, public labels, published baselines. What cannot be reproduced without the mint is the token itself, and that is the honest boundary of this release: not the benchmark, not the target, not the baselines.

6. Limitations

• Every number here is measured at the relaxed, minimum-energy geometry. On rattled geometries of the same molecules the model is 0.955 mHa and 89.4 percent inside chemical accuracy. Structures far from equilibrium are outside what this release was measured on.
• The target is defined for a specific active space, 6 electrons in 6 orbitals at CASCI(6,6)/6-31G. Other window sizes are out of scope for this release.
• Molecules of 10–14 heavy atoms containing C, N, O, S and Cl. Drug-sized molecules are served by a different model against a different target, and this checkpoint does not serve them.
• Tokens carry no molecular-size information. They describe a fixed frontier region. On size-dependent (extensive) properties such as total internal energy, tokens are worse than counting atoms. Pair them with a size-aware descriptor when the target scales with molecule size.
• One token per geometry, with no reuse across conformers. Molecular-dynamics force evaluation is not a target application. The intended use is scoring libraries of distinct molecules.
• Main test sets come from an enumerated molecule library (GDB-13), which is not a fully realistic out-of-distribution test. On real PubChem compounds at 14 heavy atoms, accuracy retention falls to 88.0% and the advantage over the classical descriptor narrows.

7. Legal

The Canis M weights are released under Apache 2.0.

The token pack is licensed CC BY-NC 4.0: free to use, share and build on for research and evaluation, not for commercial redistribution.

Citation

@article{karli2026tokenising,
  title   = {Tokenising quantum data for label-efficient training of molecular models},
  author  = {Karli, Derya},
  journal = {ChemRxiv},
  year    = {2026},
  doi     = {10.26434/chemrxiv.15009119/v1},
  url     = {https://doi.org/10.26434/chemrxiv.15009119/v1}
}

The full benchmark, including the control experiment against the raw integrals, the transfer results and the failure analysis, is in the preprint above.

8. Contact

TokenService access, and minting for your own models: info@siriusquantum.com

Model, integration and bug reports: dev@siriusquantum.com

siriusquantum.com