openadnet

Code and baselines for PXR (pregnane X receptor) activity modeling on the OpenADMET / Hugging Face challenge data: RDKit fingerprints plus classical regressors, optional PyTorch Geometric graph models, HuggingFace encoder regressors, delta learning, ensembles, submission CSV helpers, uncertainty (including conformal-style tooling), and visualization (e.g. TMAP, plots in viz).

Installation

From the repository root (Python ≥ 3.13):

pip install -e .

Optional extras (see pyproject.toml):

pip install -e ".[dl]"     # torch, transformers, torch-geometric — GNNs & HF regressors
pip install -e ".[hydra]"  # Hydra for experiment sweeps (e.g. `scripts/hydra_gnn_sweep.py`)

Training data are loaded via Hugging Face Hub on first use and cached locally; set HF_TOKEN for higher rate limits.

Repository layout (high level)

• src/baseline.py, src/features_data.py, src/score_data.py — descriptor grid, CV loop, default baseline run.
• src/models/ — GNNRegressor, HuggingFaceRegressor, ensembles, cv_dl for neural CV; src/models/data/graph.py builds PyG graphs from SMILES.
• src/delta_learning.py — delta-learning helpers used with the baseline / DL stack.
• src/submission.py — validate predictions and write challenge-shaped submission files.
• src/uncertainty/ — uncertainty and related plotting utilities.
• scripts/ — CV drivers (cv_gnn_regressor.py, cv_hf_regressor.py, …), submission helpers, TMAP HTML, etc.
• examples/ — small runnable snippets (HF CV, GNN subset, holdout fits).

Fingerprint grid

Descriptors are built for fp sizes 512, 1024, 2048, 4096. Morgan fingerprints use radii 0, 1, 2, 3 (RDKit bond-radius / “hop” count), named morgan_r{radius}_{bits|count}_{size}. For each size, RDKit, atom pair, and topological torsion are also included — each as binary (*_bits_{size}) and count (*_count_{size}) via GetFingerprintAsNumPy / GetCountFingerprintAsNumPy, plus rdkit_phys_props. Per-molecule values are cached on disk under ~/.cache/openadnet/fingerprints (override with OPENADNET_FP_CACHE; bump FP_CACHE_VERSION in features_data.py if definitions change).

CV result cache

Completed (descriptor, model) cross-validation metrics are stored in outputs/baseline_cv_cache.json keyed by a hash of the training SMILES + target and the CV config. Reruns skip pairs already in the cache. Remove the file or change CV_RESULT_CACHE_SCHEMA in baseline.py to force a full recompute.

PyG GNN (example run)

Illustrative GIN encoder, 100 epochs per fold, 3-fold CV (script default --n-splits unless overridden), other settings default (scripts/cv_gnn_regressor.py). Command: PYTHONPATH=src python scripts/cv_gnn_regressor.py --epochs 100.

Per-fold CSV: outputs/dl_cv_gnn_gin_e100_ns3.csv. This is not directly comparable row-for-row to the sklearn baseline table below (different fold count, model family, and training budget).

Latest baseline CV

Artifacts

After a run, see:

• outputs/baseline_cv_results.csv — full numeric results
• outputs/baseline_cv_results.html — the same table as standalone HTML (also embedded above via better-tables)

Run

cd openadnet
PYTHONPATH=src python src/score_data.py

To refresh the leaderboard table from cached JSON only (no new CV runs), use scripts/readme_from_baseline_cache.py — it fails if any pair is missing from outputs/baseline_cv_cache.json (use --fill-missing to compute missing pairs first).

Requires Hugging Face Hub access for the training CSV on first load (cached afterward). Set HF_TOKEN for higher rate limits.

Graph- and transformer-based CV (optional openadnet[dl]) is wired through scripts/cv_gnn_regressor.py, scripts/cv_hf_regressor.py, and related drivers under scripts/; see docs/pyg_gnn.md for the PyG pipeline. PyG GNN CV defaults to 50 epochs per fold (--epochs to change); use --cpu if CUDA runs out of memory.

Custom estimators and CV

Use the same cross-validation loop as score_data.py, but pass your own regressors mapping (string label → unfitted scikit-learn regressor). Labels appear in the results table under model.

Steps

1. From the openadnet package directory, set PYTHONPATH=src so modules baseline, load_data, and features_data import correctly.
2. Load the training table and build RDKit molecules from SMILES (same pattern as score_data.py).
3. Build a regressors dict: keys are short names for reporting; values must be sklearn-style regressors implementing fit / predict (typically unfitted instances).
4. Optionally set descriptor_names to a subset of list_descriptor_names() from features_data (otherwise the full grid runs).
5. Optionally set BaselineCVConfig (y_col, n_splits, shuffle, cv_random_state, model_random_state).
6. Call run_baseline_cv(...) with your regressors and config. Use cv_cache_path pointing to a separate JSON file if you do not want custom runs mixed into the default outputs/baseline_cv_cache.json, or set use_cv_cache=False to always refit. show_progress=False disables tqdm.

Pipeline wrapping: make_regressor_pipeline in baseline.py prepends SimpleImputer and, only when the key is exactly ridge, elasticnet, or svr, a StandardScaler. Other keys get imputer + model only. If your estimator needs scaling under a different name, wrap it in a small sklearn Pipeline (e.g. StandardScaler then your regressor) and pass that as the dict value.

Example

from pathlib import Path

from rdkit import Chem
from sklearn.linear_model import HuberRegressor

from baseline import BaselineCVConfig, run_baseline_cv
from load_data import train

mols = list(train["SMILES"].apply(Chem.MolFromSmiles))

regressors = {
    "huber": HuberRegressor(epsilon=1.35, max_iter=200),
}

results = run_baseline_cv(
    train,
    mols,
    descriptor_names=["morgan_r2_bits_2048", "rdkit_phys_props"],
    regressors=regressors,
    config=BaselineCVConfig(n_splits=5),
    cv_cache_path=Path("outputs/baseline_cv_custom.json"),
    use_cv_cache=True,
    show_progress=True,
)
print(results)

Run with: PYTHONPATH=src python your_script.py from the openadnet package root.