Download feature_extraction.py from Delower/herg-xgboost: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/Delower/herg-xgboost/resolve/main/feature_extraction.py
- Command line
-
hf download hf://Delower/herg-xgboost/feature_extraction.py
-
curl -L -o feature_extraction.py https://huggingface.co/Delower/herg-xgboost/resolve/main/feature_extraction.py
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 | |