ADMET Properties Prediction

In drug discovery, a compound's biological activity against a target is only one dimension of its drug candidacy. The vast majority of drug candidates fail in clinical trials not because they are inactive, but because they have unfavorable pharmacokinetic or safety properties. ADMET prediction aims to predict these properties in silico, early in the pipeline, before expensive in vitro or in vivo experiments are conducted.

ADMET stands for Absorption, Distribution, Metabolism, Excretion, and Toxicity. Together, these properties determine how a drug moves through the body, whether it reaches its target at therapeutic concentrations, and whether it is safe to administer. ML models for ADMET prediction are now standard components of hit-to-lead and lead optimization workflows at pharmaceutical companies.

What ADMET Means and Why It Matters in Drug Discovery

The drug development pipeline is famously expensive and failure-prone. It costs an estimated $2 billion and 10-15 years to bring a single drug to market. Approximately 90% of drug candidates that enter phase I clinical trials ultimately fail. Of these failures, roughly 40% are due to unfavorable pharmacokinetic properties and 20% are due to toxicity. Predicting ADMET properties computationally before synthesis can dramatically reduce this failure rate.

Key ADMET Properties

Caco-2 Permeability

Caco-2 cells are a human colorectal adenocarcinoma cell line whose permeability characteristics closely mimic the intestinal epithelium. Caco-2 Papp (apparent permeability coefficient) is one of the most widely measured ADMET endpoints. It predicts how well a drug is absorbed through the gut wall. Values above 10 x 10^-6 cm/s are generally considered high permeability. LogPapp is often predicted by ML models since the raw values span orders of magnitude.

LogP and LogS (Lipophilicity and Solubility)

LogP (octanol-water partition coefficient) measures lipophilicity. High LogP compounds are more lipophilic: better at crossing membranes but often less soluble and more prone to CYP metabolism. Aqueous solubility (logS) is a critical absorption prerequisite. Many ML models predict logS from SMILES using Morgan fingerprints or GNNs, with datasets like the Huuskonen or ESOL benchmark.

hERG Inhibition

The hERG (human ether-a-go-go-related gene) potassium channel regulates the heart's electrical activity. hERG inhibition prolongs the QT interval and can cause fatal cardiac arrhythmias. hERG blockers have caused several drug withdrawals (terfenadine, cisapride). Predicting hERG liability early is critical. This is a binary classification problem (inhibitor vs. non-inhibitor) with IC50 cutoff typically at 10 micromolar.

CYP Inhibition

Cytochrome P450 enzymes are the primary metabolic pathway for most drugs. Inhibiting CYP isoforms (3A4, 2D6, 2C9, 1A2, 2C19) can lead to drug-drug interactions by reducing the metabolism of co-administered drugs. The Tox21 and ChEMBL datasets contain CYP inhibition data. Modeling CYP inhibition is typically framed as binary classification (inhibitor at a given IC50 threshold).

Plasma Protein Binding (PPB)

Only the unbound fraction of a drug is pharmacologically active. High PPB (above 95%) reduces the free drug available for target engagement and can affect both efficacy and clearance. PPB is typically modeled as a regression task, predicting the percentage bound.

Available Datasets

The Therapeutics Data Commons (TDC) is the recommended starting point. It provides pre-split benchmarks with standardized evaluation protocols for over 20 ADMET endpoints, accessible via the PyTDC Python package. This prevents data leakage from inconsistent splitting practices.

Featurization Approaches for ADMET

The choice of featurization significantly impacts ADMET model performance:

• Morgan fingerprints (ECFP4/ECFP6): Fast, interpretable, strong baseline for most endpoints. Works well with Random Forest and XGBoost.
• RDKit physicochemical descriptors: Particularly effective for endpoints with known physical chemistry drivers (e.g., logS correlates with logP and polar surface area).
• Combined fingerprint + descriptors: Often the best classical ML approach for ADMET.
• Graph representations (molecular graphs): The input for GNN-based ADMET models. Effective for larger datasets and complex property landscapes.
• Pre-trained molecular transformers: Models like ChemBERTa, MolBERT, or Uni-Mol provide strong transfer learning for small ADMET datasets where fine-tuning is practical.

Model Architectures

Random Forest and XGBoost Baseline

For datasets with fewer than 5,000 compounds (which is most ADMET benchmarks), Random Forest or XGBoost on Morgan fingerprints is a strong and stable baseline. These models are fast to train, easy to interpret with SHAP, and resistant to overfitting through regularization. In TDC leaderboard comparisons, gradient boosting often matches GNN performance on small ADMET datasets.

Multitask Neural Networks

ADMET prediction benefits particularly well from multitask learning. Many ADMET properties share underlying physicochemical causes: lipophilicity influences both membrane permeability (absorption) and CYP metabolism. Training a single neural network with multiple output heads for related tasks allows the model to share low-level representations, effectively increasing the training data per task.

A multitask architecture uses shared lower layers (computing a molecular representation) and separate task-specific output layers. This is natively supported in DeepChem through MultitaskClassifier and MultitaskRegressor.

Graph Neural Networks

AttentiveFP and MPNN (Message Passing Neural Network) architectures from DeepChem have shown strong performance on several TDC ADMET benchmarks. They process molecular graphs directly, learning atom and bond representations through message passing. For ADMET tasks with 1,000-5,000 compounds, GNNs do not consistently outperform fingerprint-based models, but on larger aggregated datasets they tend to generalize better across scaffold diversity.

Code Example: ADMET Prediction with DeepChem

import deepchem as dc
import numpy as np
from deepchem.models import AttentiveFPModel
from sklearn.metrics import roc_auc_score, mean_absolute_error

# -------------------------------------------------------
# 1. Load an ADMET dataset from TDC via DeepChem loaders
# -------------------------------------------------------
# Example: hERG inhibition (binary classification)
# Install: pip install PyTDC deepchem

from tdc.single_pred import ADME, Tox

# Load hERG dataset
data = Tox(name='hERG')
split = data.get_split()  # default scaffold split

train_df = split['train']
valid_df = split['valid']
test_df  = split['test']

print(f"Train: {len(train_df)}, Valid: {len(valid_df)}, Test: {len(test_df)}")

# -------------------------------------------------------
# 2. Fingerprint-based baseline: XGBoost on ECFP4
# -------------------------------------------------------
from rdkit import Chem
from rdkit.Chem import AllChem
import numpy as np
from xgboost import XGBClassifier

def smiles_to_ecfp4(smiles_list, n_bits=2048):
    X = np.zeros((len(smiles_list), n_bits), dtype=np.uint8)
    for i, smi in enumerate(smiles_list):
        mol = Chem.MolFromSmiles(smi)
        if mol is not None:
            fp = AllChem.GetMorganFingerprintAsBitVect(mol, radius=2, nBits=n_bits)
            fp.ToNumpyArray(X[i])
    return X

X_train = smiles_to_ecfp4(train_df['Drug'].tolist())
X_valid = smiles_to_ecfp4(valid_df['Drug'].tolist())
X_test  = smiles_to_ecfp4(test_df['Drug'].tolist())

y_train = train_df['Y'].values.astype(int)
y_valid = valid_df['Y'].values.astype(int)
y_test  = test_df['Y'].values.astype(int)

clf = XGBClassifier(
    n_estimators=300,
    max_depth=6,
    learning_rate=0.05,
    subsample=0.8,
    use_label_encoder=False,
    eval_metric='logloss',
    random_state=42
)
clf.fit(X_train, y_train, eval_set=[(X_valid, y_valid)], verbose=False)

y_pred_proba = clf.predict_proba(X_test)[:, 1]
auroc = roc_auc_score(y_test, y_pred_proba)
print(f"XGBoost ECFP4 hERG AUROC: {auroc:.4f}")

# -------------------------------------------------------
# 3. DeepChem AttentiveFP for GNN-based ADMET prediction
# -------------------------------------------------------
# Prepare DeepChem dataset
featurizer = dc.feat.MolGraphConvFeaturizer(use_edges=True)

train_smiles = train_df['Drug'].tolist()
train_labels = train_df['Y'].values.astype(float)

X_dc_train = featurizer.featurize(train_smiles)
X_dc_valid = featurizer.featurize(valid_df['Drug'].tolist())
X_dc_test  = featurizer.featurize(test_df['Drug'].tolist())

dataset_train = dc.data.NumpyDataset(X=X_dc_train, y=train_labels.reshape(-1,1))
dataset_valid = dc.data.NumpyDataset(X=X_dc_valid, y=valid_df['Y'].values.reshape(-1,1))
dataset_test  = dc.data.NumpyDataset(X=X_dc_test,  y=test_df['Y'].values.reshape(-1,1))

# Define AttentiveFP model for binary classification
model = AttentiveFPModel(
    mode='classification',
    n_tasks=1,
    num_layers=3,
    num_timesteps=2,
    graph_feat_size=200,
    dropout=0.2,
    learning_rate=1e-3,
    batch_size=64,
    model_dir='./attentivefp_herg'
)

# Train
model.fit(dataset_train, nb_epoch=50, deterministic=True)

# Evaluate
metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
train_score = model.evaluate(dataset_train, [metric])
test_score  = model.evaluate(dataset_test,  [metric])
print(f"AttentiveFP hERG Train AUROC: {train_score['roc_auc_score']:.4f}")
print(f"AttentiveFP hERG Test  AUROC: {test_score['roc_auc_score']:.4f}")

Multitask Learning Example

import deepchem as dc
import numpy as np

# -------------------------------------------------------
# Multitask prediction on 5 CYP P450 isoforms
# -------------------------------------------------------
# Tasks: CYP1A2, CYP2C9, CYP2C19, CYP2D6, CYP3A4 inhibition

# Load multiple TDC tasks and align by SMILES
from tdc.multi_pred import CYPReaction  # or load each individually

# Simpler approach: use CYP450 dataset from DeepChem
tasks, datasets, transformers = dc.molnet.load_cyp450(
    featurizer='ECFP',
    splitter='scaffold'
)

train_dataset, valid_dataset, test_dataset = datasets

print(f"Tasks: {tasks}")
print(f"Train size: {len(train_dataset)}")

# Multitask classifier (shared ECFP features, 5 output heads)
model = dc.models.MultitaskClassifier(
    n_tasks=len(tasks),
    n_features=1024,
    layer_sizes=[1000, 500],
    dropouts=[0.25, 0.25],
    learning_rate=1e-3,
    batch_size=64,
    model_dir='./multitask_cyp'
)

model.fit(train_dataset, nb_epoch=30)

metric = dc.metrics.Metric(dc.metrics.roc_auc_score, np.mean)
test_scores = model.evaluate(test_dataset, [metric], transformers)
print(f"Multitask CYP Mean AUROC: {test_scores['mean-roc_auc_score']:.4f}")

Evaluation Metrics and Practical Benchmarks

Representative TDC benchmark scores to contextualize your results:

• Caco-2: State-of-the-art MAE around 0.27 log units (Uni-Mol). ECFP4 + RF achieves MAE around 0.40.
• hERG: State-of-the-art AUROC around 0.88. ECFP4 + XGBoost achieves around 0.82.
• ESOL solubility: State-of-the-art RMSE around 0.55 log units. ECFP4 + RF achieves RMSE around 0.75.
• Lipophilicity: State-of-the-art RMSE around 0.47. ECFP4 + RF achieves RMSE around 0.65.

Common Pitfalls in ADMET Modeling

• Random splitting on scaffold-diverse data: ADMET datasets often contain analog series where similar molecules appear in both train and test with random splits. This inflates metrics. Always use scaffold-based splitting for realistic evaluation.
• Ignoring assay variability: Experimental ADMET measurements have significant inter-laboratory variance (often 0.3-0.5 log units for Caco-2). Models cannot outperform the noise floor of the training data.
• Treating all ADMET tasks equally: Some endpoints (CYP inhibition, hERG) have larger, higher-quality datasets than others (BBB, oral bioavailability). Model performance expectations should reflect data quality.
• Overconfident predictions on out-of-distribution compounds: ADMET models trained on drug-like small molecules will extrapolate poorly to macrocycles, PROTACs, or natural product scaffolds. Use applicability domain analysis (distance to training set) before trusting predictions.
• Not calibrating classification models: The raw output probabilities from GNNs often need isotonic regression or Platt scaling to match actual positive rates. Calibrated probabilities are essential for threshold selection in screening campaigns.
• Neglecting endpoint correlation: LogP is a predictor for many ADMET properties. If your model predicts LogP well but ignores it when building a Caco-2 model, you are leaving information on the table. Use descriptor or embedding features derived from related properties.

Further Reading

• Therapeutics Data Commons (TDC)
• DeepChem Documentation
• Huang et al. (2021): Therapeutics Data Commons
• ChEMBL Database
• Lipinski et al. (1997): Rule-of-Five

Try it live

Explore a related model hands-on: open ADMET Predictor Dashboard (AI) and change its parameters while it runs. Everything stays in your browser.