herg-xgboost / feature_extraction.py
Delower's picture
Upload feature_extraction.py with huggingface_hub
eb3d354 verified
Raw History Blame Contribute Delete
12.2 kB
"""Feature extraction for the hERG Phase-5 models — end-to-end from SMILES, RDKit only.
Reproduces exactly the feature blocks used by the Phase-5 XGBoost models (Approach A
and the XGBoost legs of Approaches B/C), and is backwards-compatible with the Phase-3/4
blocks (Morgan / MACCS / 217 RDKit descriptors are computed with the same settings as
work/step0_lock_splits_features.py, so Phase-5 models can be compared like-for-like).
Blocks (in canonical assembly order):
morgan ECFP4 Morgan bits, radius 2, 2048 bits (Phase 3/4)
maccs MACCS keys, 166 bits (167-bit vector with placeholder bit 0 dropped) (Phase 3/4)
desc 217 RDKit molecular descriptors (Descriptors.descList, the exact
set/order of the Phase-3/4 cache, work/desc_names.json) (Phase 3/4)
physchem_extra [QED] — the one standard physicochemical property absent from the
217-descriptor set (verified programmatically; TPSA, MolLogP,
FractionCSP3, NumAromaticRings etc. are already inside `desc`,
so they are deliberately NOT duplicated here) (Phase 5)
morgan_counts Morgan radius-2 atom-environment COUNTS folded to 2048
(assembly applies log1p) (Phase 5)
ecfp6 Morgan bits, radius 3, 2048 bits (Phase 5)
fcfp4 Morgan bits, radius 2, 2048 bits, feature-class atom invariants
(FCFP4) (Phase 5)
herg hERG-targeted features (13, continuous) — see featurize_herg() (Phase 5)
pharm 2D pharmacophore pair counts (60, counts) — see featurize_pharm() (Phase 5)
morgan1024 Morgan ECFP4 bits folded to 1024 (added 2026-11-13 at Hossain's
instruction, alongside the 2048-bit default) (Phase 5)
morgan1024_counts Morgan ECFP4 counts folded to 1024 (assembly applies log1p) (Phase 5)
cdk OPTIONAL, not computed here: CDK fingerprints come from
PaDEL-Descriptor (separate Java tool); see PHASE5_RESULTS.md.
Usage:
from feature_extraction import featurize_smiles, BLOCK_ORDER
X, blocks = featurize_smiles("CCOc1ccc(cc1)...") # blocks: dict name -> 1-D np.array
Preprocessing applied at model time (NOT in this module; fit on training folds only):
- desc / physchem_extra / herg: drop near-constant & >5%-NaN columns (fit on train),
median-impute (train medians), standardize (train mean/SD) — Phase 3/4 DescPrep logic.
- morgan_counts / pharm: log1p, then the same standardisation as above.
- bit fingerprints (morgan / maccs / ecfp6 / fcfp4 / cdk): used raw.
"""
import os
import numpy as np
from rdkit import Chem, RDConfig, RDLogger
from rdkit.Chem import AllChem, MACCSkeys, rdMolDescriptors, rdFingerprintGenerator
from rdkit.Chem import ChemicalFeatures, QED
from rdkit.Chem.Descriptors import MolLogP
RDLogger.DisableLog("rdApp.*")
from rdkit.Chem import Descriptors as _Desc
DESC_NAMES = [n for n, _ in _Desc.descList] # 217, fixed order (== Phase-3/4 desc_names.json)
_DESC_FNS = dict(_Desc.descList)
BLOCK_ORDER = ["morgan", "maccs", "desc", "physchem_extra", "morgan_counts",
"ecfp6", "fcfp4", "herg", "pharm", "morgan1024", "morgan1024_counts"]
BLOCK_SIZES = {"morgan": 2048, "maccs": 166, "desc": 217, "physchem_extra": 1,
"morgan_counts": 2048, "ecfp6": 2048, "fcfp4": 2048, "herg": 13, "pharm": 60,
"morgan1024": 1024, "morgan1024_counts": 1024}
# ---------------------------------------------------------------- hERG block ----
# Method (documented approximation, no fitted parameters):
# * Protonatable / ionizable centres are identified with RDKit's BaseFeatures
# feature factory (PosIonizable / NegIonizable families).
# * Each PosIonizable centre is assigned a class pKa by atom environment:
# aromatic pyridine-like N ......... 5.2
# imidazole-like aromatic N (5-ring, >=2 ring N) ... 7.0
# aniline-like N (attached to aromatic C) ......... 4.6
# other (aliphatic amine etc.) .................... 9.5
# Fraction protonated at pH 7.4 for a centre: f = 1 / (1 + 10^(7.4 - pKa)).
# * logD(7.4) estimate: MolLogP - log10(1 + 10^(pKa_base - 7.4)) using the strongest
# basic centre, and additionally - log10(1 + 10^(7.4 - 4.5)) if a carboxylic-acid
# group is present (assumed acid pKa 4.5). This is a crude class-pKa approximation
# of logD, NOT a measured or rigorously predicted logD — it is labelled as such
# everywhere it is used.
_CLASS_PKA = {"pyridine": 5.2, "imidazole": 7.0, "aniline": 4.6, "aliphatic": 9.5}
_ACID_PKA = 4.5
_PH = 7.4
_factory = None
def _get_factory():
global _factory
if _factory is None:
cands = [os.path.join(RDConfig.RDDataDir, "BaseFeatures.fdef"),
os.path.join(RDConfig.RDDataDir, "Code", "GraphMol", "ChemicalFeatures",
"BaseFeatures.fdef")]
fdef = next(p for p in cands if os.path.exists(p))
_factory = ChemicalFeatures.BuildFeatureFactory(fdef)
return _factory
def _classify_base(atom, mol):
if atom.GetIsAromatic():
ring = mol.GetRingInfo()
for r in ring.AtomRings():
if atom.GetIdx() in r and len(r) == 5 and sum(1 for i in r if mol.GetAtomWithIdx(i).GetAtomicNum() == 7) >= 2:
return "imidazole"
return "pyridine"
for nb in atom.GetNeighbors():
if nb.GetIsAromatic():
return "aniline"
return "aliphatic"
def _frac_prot(pka, ph=_PH):
return 1.0 / (1.0 + 10.0 ** (ph - pka))
HERG_NAMES = ["n_pos_ionizable", "n_neg_ionizable", "expected_protonated_pH74",
"strongest_base_pKa", "logD74_est", "formal_charge", "abs_formal_charge",
"n_aromatic_rings", "frac_aromatic_atoms", "n_amine_like_N",
"n_carboxylic_acid", "has_base", "has_acid"]
def featurize_herg(mol):
feats = _get_factory().GetFeaturesForMol(mol)
pos, neg = [], []
for f in feats:
if f.GetFamily() == "PosIonizable":
pos.append(f)
elif f.GetFamily() == "NegIonizable":
neg.append(f)
pkas = []
exp_prot = 0.0
for f in pos:
aidx = f.GetAtomIds()[0]
cls = _classify_base(mol.GetAtomWithIdx(aidx), mol)
pka = _CLASS_PKA[cls]
pkas.append(pka)
exp_prot += _frac_prot(pka)
logp = MolLogP(mol)
logd = logp
if pkas:
logd -= np.log10(1.0 + 10.0 ** (max(pkas) - _PH))
n_acid = len(mol.GetSubstructMatches(Chem.MolFromSmarts("[CX3](=O)[OX2H1]")))
if n_acid:
logd -= np.log10(1.0 + 10.0 ** (_PH - _ACID_PKA))
n_ar = sum(1 for a in mol.GetAtoms() if a.GetIsAromatic())
amine_like = len(mol.GetSubstructMatches(
Chem.MolFromSmarts("[NX3;!$(NC=O);!$(NS(=O)(=O));!$(N=*);!$(N#*)]")))
fc = Chem.GetFormalCharge(mol)
return np.array([
len(pos), len(neg), exp_prot,
max(pkas) if pkas else 0.0,
logd, fc, abs(fc),
rdMolDescriptors.CalcNumAromaticRings(mol),
n_ar / max(mol.GetNumAtoms(), 1),
amine_like, n_acid,
1.0 if pkas else 0.0, 1.0 if n_acid else 0.0,
], dtype=float)
# ---------------------------------------------------------------- pharm block ---
# 2D pharmacophore pair counts. Feature points from RDKit's BaseFeatures factory,
# families mapped to 5 classes: Donor, Acceptor, Hydrophobe (Hydrophobe +
# LumpedHydrophobe + AromaticRing), PosIonizable, NegIonizable. For every pair of
# points (same point excluded; pairs taken with repetition over classes), the
# minimum topological distance between the two points' atoms is binned as
# <=2, 3-4, 5-6, >=7, giving 15 class-pairs x 4 bins = 60 counts.
_PHARM_FAMS = ["Donor", "Acceptor", "Hydrophobe", "PosIonizable", "NegIonizable"]
_FAM_MAP = {"Donor": "Donor", "Acceptor": "Acceptor", "Hydrophobe": "Hydrophobe",
"LumpedHydrophobe": "Hydrophobe", "AromaticRing": "Hydrophobe",
"PosIonizable": "PosIonizable", "NegIonizable": "NegIonizable",
"RingDonor": "Donor", "RingAcceptor": "Acceptor"}
PHARM_NAMES = [f"{a}|{b}|d{db}" for i, a in enumerate(_PHARM_FAMS) for b in _PHARM_FAMS[i:]
for db in ["<=2", "3-4", "5-6", ">=7"]]
def _dist_bin(d):
return 0 if d <= 2 else 1 if d <= 4 else 2 if d <= 6 else 3
def featurize_pharm(mol):
feats = _get_factory().GetFeaturesForMol(mol)
pts = []
for f in feats:
fam = _FAM_MAP.get(f.GetFamily())
if fam is not None:
pts.append((fam, set(f.GetAtomIds())))
out = np.zeros(60, dtype=float)
if len(pts) < 2:
return out
dm = Chem.GetDistanceMatrix(mol)
pair_index = {}
k = 0
for i, a in enumerate(_PHARM_FAMS):
for b in _PHARM_FAMS[i:]:
pair_index[(a, b)] = k
k += 4
for i in range(len(pts)):
for j in range(i + 1, len(pts)):
fa, aa = pts[i]
fb, ab = pts[j]
d = min(dm[x, y] for x in aa for y in ab)
key = (fa, fb) if (fa, fb) in pair_index else (fb, fa)
out[pair_index[key] + _dist_bin(int(d))] += 1.0
return out
# ---------------------------------------------------------------- main entry ----
_morgan_gen = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=2048)
_morgan_gen_1024 = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=1024)
_morgan_gen_r3 = rdFingerprintGenerator.GetMorganGenerator(radius=3, fpSize=2048)
_fcfp_gen = rdFingerprintGenerator.GetMorganGenerator(
radius=2, fpSize=2048,
atomInvariantsGenerator=rdFingerprintGenerator.GetMorganFeatureAtomInvGen())
from rdkit.ML.Descriptors.MoleculeDescriptors import MolecularDescriptorCalculator
_CALC = MolecularDescriptorCalculator(DESC_NAMES)
def _desc_vector(mol):
# C++-loop calculator over the descList functions; identical values/order to
# calling each descList function in Python, several-fold faster.
try:
return np.array(_CALC.CalcDescriptors(mol), dtype=float)
except Exception:
out = np.empty(len(DESC_NAMES), dtype=float)
for i, n in enumerate(DESC_NAMES):
try:
out[i] = _DESC_FNS[n](mol)
except Exception:
out[i] = np.nan
return out
def featurize_mol(mol):
"""mol: RDKit Mol -> dict block name -> 1-D float32 array (NaN-free except desc)."""
out = {}
out["morgan"] = np.asarray(_morgan_gen.GetFingerprint(mol), dtype=np.float32)
out["maccs"] = np.asarray(MACCSkeys.GenMACCSKeys(mol), dtype=np.float32)[1:] # drop bit 0
out["desc"] = _desc_vector(mol)
out["physchem_extra"] = np.array([QED.qed(mol)], dtype=float)
counts = _morgan_gen.GetCountFingerprint(mol)
arr = np.zeros(2048, dtype=np.float32)
for idx, c in counts.GetNonzeroElements().items():
arr[idx % 2048] += c
out["morgan_counts"] = arr
out["ecfp6"] = np.asarray(_morgan_gen_r3.GetFingerprint(mol), dtype=np.float32)
out["fcfp4"] = np.asarray(_fcfp_gen.GetFingerprint(mol), dtype=np.float32)
out["herg"] = featurize_herg(mol)
out["pharm"] = featurize_pharm(mol)
# Morgan ECFP4 at 1024 bits (bits + counts) — added to the Phase-5 ablation by
# Hossain's instruction of 2026-11-13 (tests whether the smaller, denser folding
# beats the 2048-bit default).
out["morgan1024"] = np.asarray(_morgan_gen_1024.GetFingerprint(mol), dtype=np.float32)
counts = _morgan_gen_1024.GetCountFingerprint(mol)
arr = np.zeros(1024, dtype=np.float32)
for idx, c in counts.GetNonzeroElements().items():
arr[idx % 1024] += c
out["morgan1024_counts"] = arr
return out
def featurize_smiles(smiles):
"""SMILES -> (assembled float32 vector in BLOCK_ORDER, blocks dict). None if unparseable."""
mol = Chem.MolFromSmiles(smiles)
if mol is None:
return None, None
blocks = featurize_mol(mol)
return np.concatenate([blocks[b] for b in BLOCK_ORDER]).astype(np.float32), blocks