| from __future__ import annotations |
|
|
| from dataclasses import dataclass |
| from typing import Dict, Iterable, List, Tuple |
|
|
| import numpy as np |
| import pandas as pd |
| from rdkit import Chem |
| from rdkit.Chem import AllChem, Descriptors, Lipinski, MolSurf, rdMolDescriptors |
| from rdkit.Chem.Scaffolds import MurckoScaffold |
| from rdkit.DataStructs import TanimotoSimilarity |
|
|
| try: |
| from rdkit.Chem import rdFreeSASA |
| except Exception: |
| rdFreeSASA = None |
|
|
|
|
| @dataclass |
| class FeatureValue: |
| value: float | None |
| available: bool |
| source: str |
| feature_type: str |
|
|
|
|
| @dataclass |
| class FeatureBundle: |
| object_id: str |
| features: Dict[str, FeatureValue] |
|
|
| def to_records(self, channel: str, round_idx: int | None = None) -> List[dict]: |
| rows: List[dict] = [] |
| for name, fv in sorted(self.features.items()): |
| rows.append( |
| { |
| "object_id": self.object_id, |
| "round": round_idx, |
| "channel": channel, |
| "feature_name": name, |
| "value": fv.value, |
| "available": bool(fv.available), |
| "source": fv.source, |
| "feature_type": fv.feature_type, |
| } |
| ) |
| return rows |
|
|
|
|
| def _fv(value: float | None, available: bool, source: str, feature_type: str) -> FeatureValue: |
| return FeatureValue(value=value, available=available, source=source, feature_type=feature_type) |
|
|
|
|
| def _safe_float(value: float | int | None) -> float | None: |
| if value is None: |
| return None |
| try: |
| v = float(value) |
| except Exception: |
| return None |
| if not np.isfinite(v): |
| return None |
| return v |
|
|
|
|
| def _compute_ligand_sasa(mol: Chem.Mol) -> Tuple[float | None, bool]: |
| if rdFreeSASA is None: |
| return None, False |
| try: |
| if mol.GetNumConformers() == 0: |
| m = Chem.AddHs(Chem.Mol(mol)) |
| status = AllChem.EmbedMolecule(m, AllChem.ETKDGv3()) |
| if int(status) != 0: |
| return None, False |
| else: |
| m = Chem.Mol(mol) |
|
|
| if m.GetNumConformers() == 0: |
| return None, False |
|
|
| radii = rdFreeSASA.classifyAtoms(m) |
| sasa = rdFreeSASA.CalcSASA(m, radii) |
| return _safe_float(sasa), True |
| except Exception: |
| return None, False |
|
|
|
|
| def build_ligand_feature_bundle( |
| ligand_id: str, |
| smiles: str, |
| fingerprint: np.ndarray, |
| reference_mol: Chem.Mol | None = None, |
| compute_partial_charges: bool = True, |
| compute_sasa: bool = True, |
| ) -> FeatureBundle: |
| mol = Chem.MolFromSmiles(smiles) |
| if mol is None: |
| raise ValueError(f"Invalid SMILES for ligand {ligand_id}: {smiles}") |
|
|
| m_h = Chem.AddHs(Chem.Mol(mol)) |
| if compute_partial_charges: |
| try: |
| AllChem.ComputeGasteigerCharges(m_h) |
| partial_charges = [] |
| for atom in m_h.GetAtoms(): |
| prop = atom.GetProp("_GasteigerCharge") if atom.HasProp("_GasteigerCharge") else "nan" |
| try: |
| q = float(prop) |
| except Exception: |
| continue |
| if np.isfinite(q): |
| partial_charges.append(q) |
| if partial_charges: |
| mean_abs_q = float(np.mean(np.abs(partial_charges))) |
| total_q = float(np.sum(partial_charges)) |
| has_q = True |
| else: |
| mean_abs_q = None |
| total_q = None |
| has_q = False |
| except Exception: |
| mean_abs_q = None |
| total_q = None |
| has_q = False |
| else: |
| mean_abs_q = None |
| total_q = None |
| has_q = False |
|
|
| aromatic_rings = rdMolDescriptors.CalcNumAromaticRings(mol) |
| formal_charge = Chem.GetFormalCharge(mol) |
| heavy_atoms = mol.GetNumHeavyAtoms() |
| frac_csp3 = rdMolDescriptors.CalcFractionCSP3(mol) |
| bertz_ct = Descriptors.BertzCT(mol) |
| balaban_j = Descriptors.BalabanJ(mol) |
| topological_complexity = rdMolDescriptors.CalcChi0v(mol) |
|
|
| if compute_sasa: |
| ligand_sasa, has_sasa = _compute_ligand_sasa(m_h) |
| else: |
| ligand_sasa, has_sasa = None, False |
|
|
| reference_similarity = None |
| scaffold_match = None |
| chemical_distance = None |
| if reference_mol is not None: |
| fp_gen = AllChem.GetMorganGenerator(radius=2, fpSize=int(fingerprint.shape[0])) |
| ref_fp = fp_gen.GetFingerprint(reference_mol) |
| lig_fp = fp_gen.GetFingerprint(mol) |
| sim = TanimotoSimilarity(ref_fp, lig_fp) |
| reference_similarity = float(sim) |
| chemical_distance = float(1.0 - sim) |
|
|
| ref_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=reference_mol) |
| lig_scaffold = MurckoScaffold.MurckoScaffoldSmiles(mol=mol) |
| scaffold_match = float(ref_scaffold == lig_scaffold) |
|
|
| features: Dict[str, FeatureValue] = { |
| "ligand_mw": _fv(_safe_float(Descriptors.MolWt(mol)), True, "rdkit", "exact"), |
| "ligand_logp": _fv(_safe_float(Descriptors.MolLogP(mol)), True, "rdkit", "exact"), |
| "ligand_tpsa": _fv(_safe_float(MolSurf.TPSA(mol)), True, "rdkit", "exact"), |
| "ligand_hbd": _fv(_safe_float(Lipinski.NumHDonors(mol)), True, "rdkit", "exact"), |
| "ligand_hba": _fv(_safe_float(Lipinski.NumHAcceptors(mol)), True, "rdkit", "exact"), |
| "ligand_rotatable_bonds": _fv(_safe_float(Lipinski.NumRotatableBonds(mol)), True, "rdkit", "exact"), |
| "ligand_aromatic_ring_count": _fv(_safe_float(aromatic_rings), True, "rdkit", "exact"), |
| "ligand_formal_charge": _fv(_safe_float(formal_charge), True, "rdkit", "exact"), |
| "ligand_partial_charge_abs_mean": _fv(mean_abs_q, has_q, "rdkit", "approximate"), |
| "ligand_partial_charge_total": _fv(total_q, has_q, "rdkit", "approximate"), |
| "ligand_topological_bertz": _fv(_safe_float(bertz_ct), True, "rdkit", "exact"), |
| "ligand_topological_balaban_j": _fv(_safe_float(balaban_j), True, "rdkit", "exact"), |
| "ligand_topological_chi0v": _fv(_safe_float(topological_complexity), True, "rdkit", "exact"), |
| "ligand_fraction_csp3": _fv(_safe_float(frac_csp3), True, "rdkit", "exact"), |
| "ligand_heavy_atom_count": _fv(_safe_float(heavy_atoms), True, "rdkit", "exact"), |
| "ligand_sasa": _fv(ligand_sasa, has_sasa, "geometric", "approximate"), |
| "similarity_to_reference": _fv(reference_similarity, reference_similarity is not None, "rdkit", "exact"), |
| "scaffold_match": _fv(scaffold_match, scaffold_match is not None, "rdkit", "exact"), |
| "chemical_distance_to_reference": _fv(chemical_distance, chemical_distance is not None, "rdkit", "exact"), |
| } |
|
|
| for i, bit in enumerate(fingerprint.astype(float).tolist()): |
| features[f"morgan_fp_{i:04d}"] = _fv(float(bit), True, "rdkit", "exact") |
|
|
| return FeatureBundle(object_id=ligand_id, features=features) |
|
|
|
|
| def build_protein_feature_bundle(target_id: str, sequence_features: Dict[str, float], structure_features: Dict[str, float]) -> FeatureBundle: |
| seq_len = float(sequence_features.get("seq_length", 1.0) or 1.0) |
| hydrophobic = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["A", "V", "I", "L", "M", "F", "W", "Y"]) |
| charged = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["K", "R", "H", "D", "E"]) |
| polar = sum(sequence_features.get(f"aa_frac_{aa}", 0.0) for aa in ["S", "T", "N", "Q", "C"]) |
|
|
| residue_count = float(structure_features.get("residue_count", 0.0)) |
| mean_extent = float(structure_features.get("mean_spatial_extent", 0.0)) |
| pocket_residues = float(structure_features.get("pocket_residue_count", 0.0)) |
|
|
| approx_volume = float(max(0.0, mean_extent**3)) |
| pocket_coverage = float(pocket_residues / max(residue_count, 1.0)) |
|
|
| features = { |
| "pocket_hydrophobic_fraction": _fv(hydrophobic, True, "protein", "exact"), |
| "pocket_charged_fraction": _fv(charged, True, "protein", "exact"), |
| "pocket_polar_fraction": _fv(polar, True, "protein", "exact"), |
| "pocket_residue_count": _fv(residue_count, True, "protein", "exact"), |
| "pocket_volume_approx": _fv(approx_volume, True, "geometric", "approximate"), |
| "pocket_coverage_fraction": _fv(pocket_coverage, True, "geometric", "approximate"), |
| "pocket_sequence_length": _fv(seq_len, True, "protein", "exact"), |
| } |
| return FeatureBundle(object_id=target_id, features=features) |
|
|
|
|
| def build_complex_feature_bundle( |
| ligand_id: str, |
| docking_score: float, |
| interface_features: Dict[str, float], |
| ligand_bundle: FeatureBundle, |
| protein_bundle: FeatureBundle, |
| ) -> FeatureBundle: |
| lig = ligand_bundle.features |
| prot = protein_bundle.features |
|
|
| logp = lig.get("ligand_logp", _fv(None, False, "rdkit", "exact")).value or 0.0 |
| tpsa = lig.get("ligand_tpsa", _fv(None, False, "rdkit", "exact")).value or 0.0 |
| charge_mag = lig.get("ligand_partial_charge_abs_mean", _fv(None, False, "rdkit", "approximate")).value |
| heavy_atoms = lig.get("ligand_heavy_atom_count", _fv(None, False, "rdkit", "exact")).value or 1.0 |
| pocket_volume = prot.get("pocket_volume_approx", _fv(None, False, "geometric", "approximate")).value or 1.0 |
| pocket_hydrophobic = prot.get("pocket_hydrophobic_fraction", _fv(None, False, "protein", "exact")).value or 0.0 |
|
|
| interface_contact_proxy = float(interface_features.get("interface_contact_proxy", max(0.0, -docking_score / 8.0))) |
| hbond_proxy = float(interface_features.get("hbond_proxy", max(0.0, tpsa / 100.0))) |
| shape_proxy = float(interface_features.get("shape_proxy", max(0.0, 1.0 / (1.0 + abs(docking_score))))) |
|
|
| contact_count = max(1.0, heavy_atoms * (0.3 + interface_contact_proxy)) |
| polar_contacts = contact_count * min(1.0, tpsa / 120.0) |
| hydrophobic_contacts = contact_count * min(1.0, max(0.0, logp) / 6.0) * (0.5 + pocket_hydrophobic) |
| clash_count = max(0.0, docking_score - 9.0) |
| min_distance = max(1.5, 6.0 - interface_contact_proxy) |
| pocket_coverage = min(1.0, contact_count / max(10.0, pocket_volume / 20.0)) |
| interaction_density = contact_count / max(1.0, pocket_volume) |
|
|
| ligand_sasa = lig.get("ligand_sasa", _fv(None, False, "geometric", "approximate")).value |
| protein_sasa = pocket_volume * 0.75 |
| if ligand_sasa is not None: |
| complex_sasa = max(1.0, protein_sasa + ligand_sasa - 0.5 * contact_count) |
| buried_sasa = max(0.0, protein_sasa + ligand_sasa - complex_sasa) |
| burial_ratio = buried_sasa / max(ligand_sasa, 1e-6) |
| sasa_available = True |
| else: |
| complex_sasa = None |
| buried_sasa = None |
| burial_ratio = None |
| sasa_available = False |
|
|
| if charge_mag is not None: |
| electrostatic_proxy = -charge_mag * max(0.5, 5.0 - min_distance) |
| electro_available = True |
| else: |
| electrostatic_proxy = None |
| electro_available = False |
|
|
| contact_energy = -0.15 * contact_count |
| steric_penalty = 0.6 * clash_count |
| hydrophobic_proxy = -0.1 * hydrophobic_contacts |
| interaction_decomp = contact_energy + hydrophobic_proxy + (electrostatic_proxy or 0.0) + steric_penalty |
|
|
| features = { |
| "complex_contact_count": _fv(float(contact_count), True, "interaction", "proxy"), |
| "complex_hbond_proxy": _fv(float(hbond_proxy), True, "interaction", "proxy"), |
| "complex_polar_contact_count": _fv(float(polar_contacts), True, "interaction", "proxy"), |
| "complex_hydrophobic_contact_proxy": _fv(float(hydrophobic_contacts), True, "interaction", "proxy"), |
| "complex_clash_count": _fv(float(clash_count), True, "interaction", "proxy"), |
| "complex_min_distance": _fv(float(min_distance), True, "geometric", "approximate"), |
| "complex_pocket_coverage": _fv(float(pocket_coverage), True, "interaction", "proxy"), |
| "complex_interaction_density": _fv(float(interaction_density), True, "interaction", "proxy"), |
| "complex_ligand_sasa": _fv(_safe_float(ligand_sasa), ligand_sasa is not None, "geometric", "approximate"), |
| "complex_protein_sasa": _fv(_safe_float(protein_sasa), True, "geometric", "approximate"), |
| "complex_sasa": _fv(_safe_float(complex_sasa), sasa_available, "geometric", "approximate"), |
| "complex_buried_sasa": _fv(_safe_float(buried_sasa), sasa_available, "geometric", "approximate"), |
| "complex_shape_complementarity": _fv(float(shape_proxy), True, "geometric", "proxy"), |
| "complex_ligand_burial_ratio": _fv(_safe_float(burial_ratio), sasa_available, "geometric", "approximate"), |
| "energy_contact_proxy": _fv(float(contact_energy), True, "energy_proxy", "proxy"), |
| "energy_electrostatic_proxy": _fv(_safe_float(electrostatic_proxy), electro_available, "energy_proxy", "proxy"), |
| "energy_steric_clash_penalty": _fv(float(steric_penalty), True, "energy_proxy", "proxy"), |
| "energy_hydrophobic_proxy": _fv(float(hydrophobic_proxy), True, "energy_proxy", "proxy"), |
| "energy_interaction_decomposition": _fv(float(interaction_decomp), True, "energy_proxy", "proxy"), |
| } |
|
|
| return FeatureBundle(object_id=ligand_id, features=features) |
|
|
|
|
| def build_rdock_feature_bundle( |
| ligand_id: str, |
| parsed_row: Dict[str, float | int | str | bool | None], |
| ) -> FeatureBundle: |
| """Build a feature bundle from rDock-native and rDock-derived per-ligand outputs.""" |
|
|
| def _as_feature( |
| key: str, |
| source: str, |
| ftype: str, |
| ) -> FeatureValue: |
| value = _safe_float(parsed_row.get(key)) |
| return _fv(value, value is not None, source, ftype if value is not None else "unavailable") |
|
|
| features: Dict[str, FeatureValue] = { |
| "rdock_total_score": _as_feature("rdock_total_score", "rdock_native", "exact"), |
| "rdock_pose_rank": _as_feature("rdock_pose_rank", "rdock_native", "exact"), |
| "n_generated_poses": _as_feature("n_generated_poses", "rdock_native", "exact"), |
| "best_pose_score": _as_feature("best_pose_score", "rdock_native", "exact"), |
| "mean_top3_pose_score": _as_feature("mean_top3_pose_score", "rdock_native", "exact"), |
| "mean_top5_pose_score": _as_feature("mean_top5_pose_score", "rdock_native", "exact"), |
| "std_top5_pose_score": _as_feature("std_top5_pose_score", "rdock_native", "exact"), |
| "pose_score_gap_1_2": _as_feature("pose_score_gap_1_2", "rdock_native", "exact"), |
| "rdock_restraint_term": _as_feature("rdock_restraint_term", "rdock_native", "exact"), |
| "rdock_internal_ligand_term": _as_feature("rdock_internal_ligand_term", "rdock_native", "exact"), |
| "rdock_polar_term": _as_feature("rdock_polar_term", "rdock_native", "exact"), |
| "rdock_vdw_term": _as_feature("rdock_vdw_term", "rdock_native", "exact"), |
| "top_pose_rmsd_consistency": _as_feature("top_pose_rmsd_consistency", "rdock_derived", "proxy"), |
| "contact_overlap_consistency": _as_feature("contact_overlap_consistency", "rdock_derived", "proxy"), |
| "hotspot_contact_frequency": _as_feature("hotspot_contact_frequency", "rdock_derived", "proxy"), |
| "subpocket_match_score": _as_feature("subpocket_match_score", "rdock_derived", "proxy"), |
| "replicate_mean_score": _as_feature("replicate_mean_score", "rdock_derived", "proxy"), |
| "replicate_score_variance": _as_feature("replicate_score_variance", "rdock_derived", "proxy"), |
| "replicate_consensus_score": _as_feature("replicate_consensus_score", "rdock_derived", "proxy"), |
| } |
| return FeatureBundle(object_id=ligand_id, features=features) |
|
|
|
|
| def merge_bundles(object_id: str, bundles: Iterable[FeatureBundle]) -> FeatureBundle: |
| merged: Dict[str, FeatureValue] = {} |
| for bundle in bundles: |
| merged.update(bundle.features) |
| return FeatureBundle(object_id=object_id, features=merged) |
|
|
|
|
| def bundles_to_wide_frames( |
| bundles: List[FeatureBundle], |
| ordered_feature_names: List[str] | None = None, |
| ) -> Tuple[pd.DataFrame, pd.DataFrame, List[str]]: |
| if not bundles: |
| return pd.DataFrame(), pd.DataFrame(), [] |
|
|
| if ordered_feature_names is None: |
| feature_set = set() |
| for bundle in bundles: |
| feature_set.update(bundle.features.keys()) |
| ordered_feature_names = sorted(feature_set) |
|
|
| value_rows = [] |
| mask_rows = [] |
| for bundle in bundles: |
| vrow = {"ligand_id": bundle.object_id} |
| mrow = {"ligand_id": bundle.object_id} |
| for name in ordered_feature_names: |
| fv = bundle.features.get(name) |
| if fv is None or not fv.available or fv.value is None: |
| vrow[name] = np.nan |
| mrow[f"mask_{name}"] = 0 |
| else: |
| vrow[name] = float(fv.value) |
| mrow[f"mask_{name}"] = 1 |
| value_rows.append(vrow) |
| mask_rows.append(mrow) |
|
|
| return pd.DataFrame(value_rows), pd.DataFrame(mask_rows), ordered_feature_names |
|
|
|
|
| def compute_feature_diagnostics(values_df: pd.DataFrame, masks_df: pd.DataFrame, target: pd.Series | None = None) -> pd.DataFrame: |
| if values_df.empty: |
| return pd.DataFrame(columns=["feature", "missing_frac", "mean", "std", "min", "max", "is_constant", "corr_to_target"]) |
|
|
| numeric_cols = [c for c in values_df.columns if c != "ligand_id"] |
| rows = [] |
| for col in numeric_cols: |
| vals = pd.to_numeric(values_df[col], errors="coerce") |
| mask_col = f"mask_{col}" |
| if mask_col in masks_df.columns: |
| missing_frac = 1.0 - float(pd.to_numeric(masks_df[mask_col], errors="coerce").mean()) |
| else: |
| missing_frac = float(vals.isna().mean()) |
|
|
| finite_vals = vals[np.isfinite(vals)] |
| is_constant = finite_vals.nunique(dropna=True) <= 1 if not finite_vals.empty else True |
|
|
| if target is not None and len(target) == len(vals): |
| target_num = pd.to_numeric(target, errors="coerce") |
| paired = pd.concat([vals, target_num], axis=1).dropna() |
| if paired.shape[0] >= 3 and paired.iloc[:, 0].nunique(dropna=True) > 1 and paired.iloc[:, 1].nunique(dropna=True) > 1: |
| corr = paired.iloc[:, 0].corr(paired.iloc[:, 1]) |
| corr_val = float(corr) if corr is not None and np.isfinite(corr) else np.nan |
| else: |
| corr_val = np.nan |
| else: |
| corr_val = np.nan |
|
|
| rows.append( |
| { |
| "feature": col, |
| "missing_frac": float(missing_frac), |
| "mean": float(finite_vals.mean()) if not finite_vals.empty else np.nan, |
| "std": float(finite_vals.std()) if not finite_vals.empty else np.nan, |
| "min": float(finite_vals.min()) if not finite_vals.empty else np.nan, |
| "max": float(finite_vals.max()) if not finite_vals.empty else np.nan, |
| "is_constant": bool(is_constant), |
| "corr_to_target": corr_val, |
| } |
| ) |
|
|
| return pd.DataFrame(rows).sort_values(["missing_frac", "feature"], ascending=[False, True]).reset_index(drop=True) |
|
|
