--- license: cc-by-4.0 language: - en tags: - materials-science - out-of-distribution-detection - graph-neural-networks - benchmark pretty_name: MOOD - Materials Out-of-Distribution Detection configs: - config_name: default description: All retained (dataset, architecture, split) settings. --- # MOOD: Materials Out-of-Distribution Detection Benchmark Pre-extracted graph neural network embeddings, trained checkpoints, density-flow models, OOD split indices, supervised-probe outputs, and detector evaluation artifacts for the MOOD benchmark. > **Anonymous review submission.** Authors and affiliations will be > filled in at camera-ready. The accompanying source code lives at > [https://anonymous.4open.science/r/MOOD-Bench-820B/](https://anonymous.4open.science/r/MOOD-Bench-820B/) > during the review period. ## Layout Per-setting directories are keyed by `///fold_0/` (or `seed_42/` under `flow_models/`), where `` is one of the five MatBench tasks, `` is one of `alignn`, `cgcnn`, `schnet`, `dimenet`, and `` is one of the 15 OOD predicates. Most directories use the `matbench_` form (`matbench_dielectric`, `matbench_log_gvrh`, etc.); `risk_coverage/` is the lone exception and uses bare names (`dielectric`, `log_gvrh`, etc.). | Path | Description | Approx. size | |---|---|---| | `embeddings/matbench_///fold_0/{train,id_test,ood_test}.npy` | Penultimate-layer GNN embeddings on ID train, ID test, and OOD test for every retained (dataset, architecture, split) setting. **Released raw — not L2-normalized.** Each `fold_0/` also contains matching `*_pred.npy` and `*_targets.npy` for traceability. | 1.1 GB | | `splits/matbench_//{train_idx,id_test_idx,ood_test_idx,balanced_id_test_idx,balanced_ood_test_idx}.npy` + `stats.json` | MatBench-row indices for each split partition. The `balanced_*_idx.npy` files index the **original MatBench dataset** and are subsets of the corresponding `*_test_idx.npy` files; use them when evaluating on a 1:1 ID/OOD subsample. Also covers OMee data-driven split protocols (LOCO, SparseXcluster, SparseYcluster) under `splits/omee/`. | 7 MB | | `checkpoints/matbench_///fold_0/{best_model.pt or *.keras, config.yaml}` | Trained GNN checkpoints. ALIGNN and CGCNN ship `best_model.pt` (PyTorch); SchNet and DimeNet++ ship `*.keras` (kgcnn). `config.yaml` documents the per-cell run (architecture, dataset, split_type, fold, embedding_dim, n_train / n_id_test / n_ood_test, best_val_mae). | 3.4 GB | | `flow_models/matbench_///fold_0/seed_42/{flow_state.pt, id_log_prob.npy, ood_log_prob.npy, results.json, *_nll_history.npy}` | Trained Real-NVP normalising flows (8 coupling layers, hidden 128) plus pre-computed log-densities on ID and OOD test embeddings. | 4.1 GB | | `linear_probes/matbench_///fold_0/results.json` | Per-setting linear-probe summary. Keys: `mean_auroc`, `std_auroc`, `cv_aurocs` (list of per-fold AUROCs from 5-fold stratified CV with `C=1.0`), `n_id_used`, `n_ood_used`, `config`. | 1 MB | | `linear_probes_mlp/matbench_///fold_0/results.json` | Same per-setting summary for the MLP probe (hidden 256→128, `alpha=1.0`, early stopping). | 1 MB | | `results/matbench_///fold_0/auroc.json` | Per-cell consolidated AUROC + FPR95 for every detector reported in the paper, plus a `knn_sweep` block over $k \in \{5, 10, 20, 50\} \times \{\text{L2-norm}, \text{raw}\}$. The metadata fields `n_id_test` and `n_ood_test` are the test-pool sizes used to compute these AUROCs. | 1 MB | | `risk_coverage////fold_0//results.json` | Per-(cell, detector) risk–coverage curves for eight detectors with cluster-stored artifacts: `flow, iforest, knn_k10, kpca, lof, mds_bic, norm, ocsvm`. Keys: `aurc_actual` (the deployment-relevant AURC), `aurc_oracle`/`aurc_random`/`aurc_constant` (normalization references for SPE), `spe`, plus `coverages` and `risks` arrays for plotting. **Note**: this directory uses bare dataset names (`dielectric/`), not the `matbench_dielectric/` prefix used elsewhere. | 10 MB | | `croissant.json` | Croissant 1.0 metadata (Core + Responsible AI fields), enumerating every directory above. | — | ## Benchmark axes - **5 MatBench regression tasks**: dielectric (refractive index), log_gvrh (log shear modulus), log_kvrh (log bulk modulus), perovskites (formation energy), phonons (highest phonon frequency). - **4 GNN architectures**: ALIGNN ($d{=}256$), CGCNN ($d{=}128$), SchNet ($d{=}64$), DimeNet++ ($d{=}64$). - **15 deterministic OOD splits**: 6 compositional (carbide, chalcogenide, halide, intermetallic, nitride, oxide) and 9 structural (cubic, hexagonal, tetragonal, orthorhombic, monoclinic, triclinic, high-spacegroup, low-spacegroup, perovskite). The Cartesian product yields 300 candidate (dataset, architecture, split) settings; **257 are retained** after filtering splits with fewer than 50 minority-class samples and excluding 7 settings where CGCNN training collapsed on phonons. ## Representative sample for review The full release is ~9.2 GB. For a smaller representative sample (NeurIPS Evaluations & Datasets requires a sample for datasets > 4 GB), the **`embeddings/matbench_dielectric/`** subtree is a self-contained slice: - **Size:** ~132 MB (504 `.npy` files) - **Coverage:** 1 of 5 MatBench tasks (`dielectric`) × all 4 architectures (ALIGNN, CGCNN, SchNet, DimeNet++) × all 14 retained OOD splits × `{train, id_test, ood_test}` embeddings + matching `*_pred.npy` / `*_targets.npy`. - **Sample URL:** [`/embeddings/matbench_dielectric`](https://huggingface.co/datasets/mood-anonymous/mood-benchmark/tree/main/embeddings/matbench_dielectric) - **How the sample was created:** the dielectric task was selected as the smallest-by-disk method-bottlenecked dataset (132 MB embeddings) while still covering the full benchmark structure — every architecture and every retained split is represented, so a reviewer can drop in a detector via the Quick start below and reproduce the layout the benchmark exercises. The other 4 tasks (`log_gvrh`, `log_kvrh`, `perovskites`, `phonons`) follow the identical layout in the full release. ## Setup ```bash pip install huggingface_hub numpy scikit-learn ``` `huggingface_hub` and `numpy` are required for the first two examples; `scikit-learn` is needed only for the full reproduction example. ## Quick start 1 — load embeddings for a new detector ```python import numpy as np from huggingface_hub import hf_hub_download REPO = "mood-anonymous/mood-benchmark" SETTING = "matbench_dielectric/alignn/comp_halide/fold_0" def fetch(name): return np.load(hf_hub_download( repo_id=REPO, filename=f"embeddings/{SETTING}/{name}.npy", repo_type="dataset", )) z_train = fetch("train") # (n_train, d) raw z_id_te = fetch("id_test") # (n_id_test, d) raw z_ood_te = fetch("ood_test") # (n_ood_test, d) raw # Distance- and KNN-based detectors should L2-normalize first; density- # and isolation-based detectors typically use raw embeddings. def l2(x): return x / np.linalg.norm(x, axis=1, keepdims=True) ``` ## Quick start 2 — read a per-cell risk–coverage curve ```python import json from huggingface_hub import hf_hub_download REPO = "mood-anonymous/mood-benchmark" # risk_coverage/ uses bare dataset names (no "matbench_" prefix). SETTING = "dielectric/alignn/comp_halide/fold_0" with open(hf_hub_download( REPO, filename=f"risk_coverage/{SETTING}/mds_bic/results.json", repo_type="dataset", )) as f: rc = json.load(f) print("AURC (deployment):", rc["aurc_actual"]) print("SPE:", rc["spe"]) # rc["coverages"] / rc["risks"] are arrays for plotting risk vs coverage. ``` ## Quick start 3 — end-to-end detector evaluation (KNN k=20 norm) A full evaluation loop for one detector: load embeddings, L2-normalize for distance-based scoring, use the full ID and OOD test pools (sizes match the `n_id_test` / `n_ood_test` metadata in `auroc.json`), and compute AUROC. ```python import numpy as np from huggingface_hub import hf_hub_download from sklearn.neighbors import NearestNeighbors from sklearn.metrics import roc_auc_score REPO = "mood-anonymous/mood-benchmark" SETTING = "matbench_dielectric/alignn/comp_halide/fold_0" def load(p): return np.load(hf_hub_download(REPO, filename=p, repo_type="dataset")) def l2(x): return x / np.linalg.norm(x, axis=1, keepdims=True) # 1. Load embeddings. z_train = load(f"embeddings/{SETTING}/train.npy") z_id_te = load(f"embeddings/{SETTING}/id_test.npy") z_ood_te = load(f"embeddings/{SETTING}/ood_test.npy") # 2. L2-normalize (standard convention for distance-based detectors). z_train, z_id_te, z_ood_te = map(l2, (z_train, z_id_te, z_ood_te)) # 3. KNN k=20 — mean Euclidean distance to k nearest train neighbours, # sign-flipped so smaller distance scores higher (= more ID-like). knn = NearestNeighbors(n_neighbors=20).fit(z_train) score_id = -knn.kneighbors(z_id_te, return_distance=True)[0].mean(1) score_ood = -knn.kneighbors(z_ood_te, return_distance=True)[0].mean(1) # 4. AUROC (positive class = ID). y = np.r_[np.ones(len(score_id)), np.zeros(len(score_ood))] print(f"KNN k=20 norm AUROC: {roc_auc_score(y, np.r_[score_id, score_ood]):.4f}") ``` Per-cell AUROC and FPR95 for every reported detector are stored alongside in `results//auroc.json` for reference. ### Optional — class-balanced 1:1 subsample The full ID and OOD test pools are typically not the same size (e.g. 350 vs 1259 for the example above). For a strict 1:1 protocol, use the balanced indices in `splits/`, which point into the **original MatBench rows** rather than into the test-array positions: ```python SPLIT = "splits/matbench_dielectric/comp_halide" id_test_idx = load(f"{SPLIT}/id_test_idx.npy") ood_test_idx = load(f"{SPLIT}/ood_test_idx.npy") bal_id_idx = load(f"{SPLIT}/balanced_id_test_idx.npy") bal_ood_idx = load(f"{SPLIT}/balanced_ood_test_idx.npy") # Map MatBench-row indices in balanced_*_idx → positions in the test arrays. def positions(test_idx, balanced_idx): pos = {int(i): k for k, i in enumerate(test_idx)} return np.array([pos[int(i)] for i in balanced_idx]) z_id_b = z_id_te [positions(id_test_idx, bal_id_idx )] z_ood_b = z_ood_te[positions(ood_test_idx, bal_ood_idx)] # Now |z_id_b| == |z_ood_b| == min(|ID_test|, |OOD_test|). ``` ## Intended uses - Evaluating new post-hoc OOD detectors on materials property prediction GNNs without retraining the encoder (use `embeddings/`). - Replicating the supervised-probe ceiling that drives the bottleneck classification (use `linear_probes/` and `linear_probes_mlp/`). - Re-aggregating the headline AUROC matrix or computing alternative metrics on top of per-cell raw scores (use `results/`). - Replotting risk–coverage curves at any coverage threshold or computing alternative selective-prediction metrics (use `risk_coverage/`). - Re-running detectors that need the trained density model (use `flow_models/`) or that need the full GNN forward pass on novel inputs (use `checkpoints/`). - Studying the bottleneck dichotomy: dielectric and log_gvrh exhibit method bottlenecks (probe recovers signal, detectors do not); log_kvrh, perovskites, phonons exhibit encoder bottlenecks (no method recovers signal). ## License All released artifacts (embeddings, checkpoints, flow models, probe outputs, AUROC tables, risk–coverage curves): **CC-BY-4.0**. Source MatBench data is **not** redistributed in this archive; it remains under its original Materials Project licensing terms and is obtained through the standard `matminer` loader. ## Citation ```bibtex @misc{mood2026, title = {MOOD: Benchmarking Post-Hoc OOD Detection for Materials Property Prediction}, author = {Anonymous}, year = {2026}, note = {Under review}, howpublished = {\url{https://anonymous.4open.science/r/MOOD-Bench-820B/}} } ```