NatalijaStepurko/orb-mp-embeddings

Layer-wise frozen ORB-v3 representations for 154,875 Materials Project crystals

A representation resource, not another Materials Project mirror. One frozen forward pass of 154,875 MP crystals through ORB-v3, kept at every layer and read-out, with the aligned property targets, fixed splits and the structures themselves, from Out-of-training properties in frozen interatomic potential embeddings are decodable and ordered by physical scale. The study has two papers, at the AI4Mat workshop (AI for Accelerated Materials Design) and the AI for Science workshop, both at NeurIPS 2026; this dataset, its gated companion and the code repository are the same for both.

You can use it to train a property head without running ORB, compare representation methods, study how information moves with depth, test retrieval or alternative probes, or compare against the companion UMA-S release — none of which requires re-running extraction.

Three levels — read this first

Start here	data/materials.parquet + embeddings/ — the reusable resource
Quick inspection	sample/ — 1,000 materials, everything joined, no large download
Paper reproduction only	reproduction/ and the tables in results/ — you do not need these to use the embeddings

The UMA embeddings live in a separate, access-gated dataset because Meta's FAIR Chemistry License requires pass-through terms — see Companion dataset below.

Layout

path	what
data/materials.parquet	the spine. 154,875 rows: ids, formula, space group (symbol and number 1–230), 9 property targets, 3 categorical labels, and the fixed seed-42 split__<target> flags. Every other file keys to it on mp_id
data/structures.parquet	the 154,875 crystal structures of Materials Project release 2026.04.13 as used: lattice (9 floats, Å), species, fractional coordinates, site count. The API serves the current release, so this is the reproducible input for every stage that embeds structures
data/external/	the two external sets of the cross-database test: jarvis_dft_3d_index (93,902 JARVIS-DFT 3D entries: labels as used, relation to MP, matched MP id), oqmd_index and oqmd_structures (the 39,900-entry OQMD stride sample, with its structures because that API has no snapshot)
embeddings/node/orb-node-{layer}.parquet	ORB-v3 mean-pooled node vectors, 256-d, six layers (encoder, gnn_stacks_0–4), 154,875 rows each. The backbone read-out is bit-identical to gnn_stacks_4 and is not stored; the manifest lists it as an alias
embeddings/edge/orb-edge-{layer}.parquet	ORB-v3 mean-pooled edge vectors, 256-d, six layers, 154,872 rows each
manifest.parquet	one row per embedding file: model, read-out, representation, layer, dimensionality, rows, and whether the representation is rotation-invariant
results/	three tables only: every probe score (probe_metrics), the bootstrap metric table (significance_full_metrics), and the composition-only baseline (controls/composition_baseline). The first two are what the released code's check step compares a rerun against; the third is the Magpie reference score its label-efficiency analysis needs. Every other result table is regenerated by the code, not deposited
reproduction/	inputs that let specific analyses be recomputed without the model weights: the atom sample, the rotation-control activations, the Magpie feature matrix; not needed for normal use
sample/	1,000-material slice for inspection

One source of truth for probe results: results/probe_metrics.parquet — one row per model × target × read-out × family × layer × estimator (2,106 rows). Every probe score the paper quotes is a view of this table. Query it rather than hunting for a file:

df[(df.model == "ORB") & (df.target == "band_gap") & (df.estimator == "xgb")]

results/ — the check tables and the composition baseline

probe_metrics.parquet holds every trained-probe result, both models, all configurations, one row per model × target × read-out × family × layer × estimator (2,106 rows); every probe score the paper quotes is a view of it. significance_full_metrics.parquet holds the bootstrap point estimates and 95 % intervals of the full metric table. controls/composition_baseline.parquet holds the composition-only (Magpie) baseline of each target, with its interval and the ORB and UMA gains over it; the label-efficiency analysis reads its comp_xgb and comp_linear as the Magpie arm's full-data score. All three have typed numeric columns. The released code regenerates every other table from the embeddings and structures here; the first two exist so that a rerun can be checked by machine.

reproduction/ — recompute, don't just read

qc_atom_sample_orb/ (29,947 per-atom ORB vectors × 6 layers) lets k-NN purity and HDBSCAN be recomputed on that sample; magpie_features.parquet is the 132-d composition matrix behind the composition-only baseline, so the baseline refits without matminer. rotation_control_orb/ holds ORB features in both rotated and unrotated states — the rotated ones come from a fresh forward pass and exist in no other cache. rotation_control_orb/ is self-contained: _subset.parquet lists the 1,000 materials used and rotation_control_metadata.parquet gives the exact rotation applied to each — the integer random_state and the 3×3 matrix — so the control can be regenerated from the model weights rather than only re-scored from the shipped vectors.

Naming convention

A file's name tells you whose data it holds, which matters once it is downloaded on its own:

• one model's data → the model is in the name (orb-…, uma-…)
• both models → no model in the name (probe_metrics, convergence_grids)
• neither, i.e. Materials Project data → no model in the name (materials, _labels, _index)

The paper's tables are not shipped here

The tables and figures are authored in the manuscript and regenerated by the released code (mlip-embedding-probes). Its stages/data/from_dataset.py turns this repository, and the gated one for the UMA numbers, into the inputs the code reads; the code then reproduces every probe, significance, control, screening, label-efficiency and stitching number on the pooled embeddings. The atom-level analyses and the experiments that re-embed structures (random weights, matched models, the rotation tests, the cross-database transfer, the from-scratch network) start from data/structures.parquet and data/external/ and need the model weights; the code's README gives the cost.

from datasets import load_dataset
mats   = load_dataset("NatalijaStepurko/orb-mp-embeddings", "materials", split="train")
emb    = load_dataset("NatalijaStepurko/orb-mp-embeddings", "embeddings_orb_node", split="train")
scores = load_dataset("NatalijaStepurko/orb-mp-embeddings", "probe_metrics", split="train")
small  = load_dataset("NatalijaStepurko/orb-mp-embeddings", "sample", split="train")   # 1,000 materials

materials schema

mp_id, formula, nsites, crystal_system, space_group_symbol, space_group_number, volume, formation_energy_per_atom, energy_above_hull, band_gap, bulk_modulus, total_magnetization, mag_density, density, metal_insulator, magnetic_label, split__<target> (each split column ∈ {train,test,""}), plus has_orb_node, has_orb_edge, has_uma_node, has_uma_edge, exclusion_reason.

structures schema

mp_id, lattice (list<float64>[9], row-major Å), species (list<string>), frac_coords (list<float64>[3·nsites]), nsites; data/external/oqmd_structures.parquet has the same columns with id in place of mp_id. The external indexes carry id, formula, nsites, crystal_system, space_group, volume, the labels as used in the paper (energy_above_hull, formation_energy_per_atom, band_gap, bulk_modulus, total_magnetization, density; JARVIS bulk modulus is the Voigt–Reuss–Hill average recomputed from its elastic tensor), relation_to_mp (in_mp_corpus, structure_match, disjoint), matched_mp_id and source.

embeddings/{node,edge}/orb-{level}-{layer}.parquet schema

mp_id, model(="orb"), level, layer, emb (list<float32>[256]). One row per material per file; level is constant within a file, matching the UMA layout. Join to data/materials.parquet on mp_id.

The sample

sample/sample_1000_materials.parquet and sample/sample_1000_orb.parquet cover the same 1,000 mp_ids, drawn with seed 42 and stratified by crystal system so the slice spans the label space. The companion gated repo carries sample_1000_uma.parquet for the same ids, so the three join on mp_id. UMA vectors are never written outside the gate, which is why the sample is split this way rather than shipped as one file.

Coverage — which materials appear where

One row per material per file, keyed by mp_id. All files cover the same 154,875 materials, matching the figure the paper reports, with one exception:

file set	rows
data/materials.parquet	154,875
data/structures.parquet	154,875
embeddings/node/*	154,875
embeddings/edge/*	154,872
companion UMA embeddings	154,875

materials.parquet carries has_orb_node, has_orb_edge, has_uma_node, has_uma_edge and exclusion_reason, so availability is a column rather than something to infer by diffing id lists.

The three materials absent from the edge read-outs — mp-1182832, mp-623782, mp-689577 — have zero edges: their cells are sparse enough (e.g. 8 atoms in 7,580 ų) that no atom pair falls inside ORB's neighbour cutoff, so a pooled edge vector does not exist for them. Their node vectors are present.

Nothing here depends on row order — join on mp_id.

Provenance & reproducibility

• Structures/targets: Materials Project database release 2026.04.13, fetched 2026-05-26 via the mp-api next-gen API; four mvc- entries absent from the public release are excluded, giving 154,875.
• Space group number is mapped from the MP-reported H–M symbol via pymatgen.symmetry.groups.SpaceGroup(sym).int_number (all 228 symbols map cleanly; the shipped CIFs are P1-dumped, so their in-file symmetry number is not the real one).
• Embeddings are the mean-pooled per-atom (node) / per-edge (edge) representations from ORB, one vector per structure per layer.
• Not included (too large to host): per-atom node embeddings and the raw per-edge tensors (≈ 1 TB in total). Available on request / regenerable from the model weights. Consequence: the atom-level analyses (per-atom purity, HDBSCAN, the same-material control and the cross-model convergence) are reported in full here as results and can be recomputed on the shipped atom subsamples (reproduction/qc_atom_sample_orb/, 29,947 atoms; the gated reproduction/convergence_atom_sample/, 30,005 atoms, which is what the paper's convergence numbers use), but not on the full corpus. Every other reported table and grid reproduces from what is shipped.

Reproducing the results

The pooled embeddings + targets + split flags are self-contained: refitting from this dataset alone recovers the published property-prediction numbers to within solver noise (verified, Δ ≤ 0.001 across regression and classification targets). Minimal example:

import numpy as np, pyarrow.parquet as pq
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import RidgeCV
from sklearn.metrics import r2_score

TARGET, LAYER = "band_gap", "gnn_stacks_2"

m = pq.read_table("data/materials.parquet").to_pydict()
y     = dict(zip(m["mp_id"], m[TARGET]))              # target value per material
split = dict(zip(m["mp_id"], m["split__" + TARGET]))  # fixed seed-42 split

e = pq.read_table(f"embeddings/node/orb-node-{LAYER}.parquet").to_pydict()
Xtr, ytr, Xte, yte = [], [], [], []
for mp, level, emb in zip(e["mp_id"], e["level"], e["emb"]):
    if level != "node" or split.get(mp) not in ("train", "test") or y[mp] is None:
        continue
    if split[mp] == "train": Xtr.append(emb); ytr.append(y[mp])
    else:                    Xte.append(emb); yte.append(y[mp])

model = make_pipeline(StandardScaler(), RidgeCV(alphas=np.logspace(-2, 3, 6)))
model.fit(np.asarray(Xtr, np.float32), ytr)
print("band_gap r2 =", r2_score(yte, model.predict(np.asarray(Xte, np.float32))))
# -> 0.689  (matches results/probe_metrics.parquet: model=ORB, read_out=node, gnn_stacks_2, linear)

XGBoost combos use xgboost.XGBRegressor/XGBClassifier(n_estimators=300, max_depth=6, learning_rate=0.05, subsample=0.8, colsample_bytree=0.8, tree_method="hist", random_state=42); linear classification uses LogisticRegression(max_iter=2000, C=1.0).

Reproducibility scope. The pooled embeddings reproduce the property-prediction, all-layers-concat, control, screening and label-efficiency results; the cross-model convergence grids reproduce on the 30,005-atom sample in the gated repository (its resampled confidence intervals draw from a 45,002-atom pool that is not deposited and needs the per-atom caches); the random-weight and matched-model controls, the rotation tests, the cross-database transfer and the from-scratch network re-embed or re-read structures and start from data/structures.parquet and data/external/ with the model weights, through the released code.

Licensing

This dataset combines permissive sources:

• Materials Project metadata, property targets and structures — CC-BY-4.0. Attribution required (see Citation).
• OQMD entries and structures (data/external/oqmd_*) — CC-BY-4.0; cite Saal et al. 2013 and Kirklin et al. 2015.
• JARVIS-DFT 3D entries (data/external/jarvis_dft_3d_index) — a work of the US National Institute of Standards and Technology, not subject to copyright in the United States; cite Choudhary et al. 2020.
• ORB-derived embeddings and the two result tables — Apache-2.0 (ORB model weights and code are Apache-2.0, which permits redistributing derived works such as embeddings).

See LICENSE-CC-BY-4.0.txt, LICENSE-Apache-2.0.txt and NOTICE.txt.

Companion dataset (UMA / FairChem)

The UMA embeddings are published separately and gated at NatalijaStepurko/uma-mp-embeddings-gated under Meta's FAIR Chemistry License (they are derivative works of the UMA weights, redistributable only under that license with pass-through; excludes China/Russia/Belarus/sanctioned jurisdictions).

Only the embedding vectors are gated. The UMA rows of the two result tables here need no license acceptance: they are aggregate research results (scores, intervals), not redistributions of Meta's Materials. The gate applies only to the raw UMA vectors.

Citation

If you use this dataset, please cite the Materials Project, ORB, and this work:

• Materials Project: Jain et al., APL Materials 1, 011002 (2013); and Horton et al., Accelerated data-driven materials science with the Materials Project.
• ORB: Neumann et al., Orb: A Fast, Scalable Neural Network Potential (2024).
• OQMD: Saal et al., JOM 65, 1501 (2013); Kirklin et al., npj Computational Materials 1, 15010 (2015).
• JARVIS-DFT: Choudhary et al., npj Computational Materials 6, 173 (2020).
• This dataset / paper: Stepurko, N. and Laulainen, J. (2026). Out-of-training properties in frozen interatomic potential embeddings are decodable and ordered by physical scale. Presented at the AI4Mat workshop (AI for Accelerated Materials Design) and the AI for Science workshop, both at NeurIPS 2026. Code: https://github.com/Natalija-Stepurko/mlip-embedding-probes