OSCR

Cross-Species Multitask Learning with Molecular and ADME Descriptors for Liver Microsomal Metabolic Stability.

Code ↔ Paper

19 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 19 matches
  1. [1] § Materials and Methods › Molecular representation and embedding › Molecular ADME and physicochemical descriptors ↔ Analysis/Edgeshaper/Dataset.py, lines 50–92 · score 0.99 · CYP2D6, synthetic accessibility, CYP1A2, iLOGP, bond acceptor, bioavailability scores
  2. [2] § Materials and Methods › Molecular representation and embedding › Molecular ADME and physicochemical descriptors ↔ Notebooks/dataset_scaffold_modelready.py, lines 75–109 · score 0.99 · CYP2D6, synthetic accessibility, CYP1A2, iLOGP, bond acceptor, bioavailability scores
  3. [3] § Materials and Methods › Molecular representation and embedding › Molecular graph ↔ Notebooks/model.py, lines 212–358 · score 0.95 · global max pooling, residual connections, Jumping Knowledge, LeakyReLU, attention heads, edge feature
  4. [4] § Materials and Methods › Molecular representation and embedding › Molecular graph ↔ Analysis/Edgeshaper/Model.py, lines 179–291 · score 0.82 · global max pooling, Jumping Knowledge, LeakyReLU, hidden, Node, residual
  5. [5] § Results › SHAP-based interpretation of ADME descriptors for liver microsomal stability across species ↔ Analysis/Edgeshaper/Dataset.py, lines 50–92 · score 0.78 · synthetic accessibility, bond donors, CYP2C9 inhibition, CYP2C19, WLOGP, ADME
  6. [6] § Results › SHAP-based interpretation of ADME descriptors for liver microsomal stability across species ↔ Notebooks/dataset_scaffold_modelready.py, lines 75–109 · score 0.78 · synthetic accessibility, bond donors, CYP2C9 inhibition, CYP2C19, WLOGP
  7. [7] § Materials and Methods › Loss function ↔ Analysis/SHAP/Train.py, lines 256–392 · score 0.73 · margin ranking loss, uncertainty weighting, focal loss, learnable, encourages, logits
  8. [8] § Materials and Methods › Loss function ↔ Analysis/SHAP/SHAP.py, lines 300–414 · score 0.69 · margin ranking loss, uncertainty weighting, focal loss, encourages, logits
  9. [9] § Materials and Methods › Training and evaluation ↔ Analysis/Edgeshaper/Utile.py, lines 402–492 · score 0.68 · precision recall curve, F1 score, Matthews, accuracy, MCC, AUPR
  10. [10] § Materials and Methods › Loss function ↔ Analysis/SHAP/SHAP.py, lines 1–56 · score 0.67 · margin ranking loss, class imbalance, focal loss
  11. [11] § Materials and Methods › Molecular representation and embedding › Molecular fingerprint ↔ Notebooks/dataset_scaffold_modelready.py, lines 426–515 · score 0.61 · hashed fingerprints, RDKit, bit, MACCS, Morgan, atom
  12. [12] § Materials and Methods › Training and evaluation ↔ Analysis/Edgeshaper/Edgeshaper.py, lines 732–815 · score 0.59 · AdamW, cosine, warmup, scheduling, optimized, metric
  13. [13] § Materials and Methods › Prediction ↔ Analysis/Edgeshaper/Model.py, lines 418–549 · score 0.57 · LayerNorm, GELU, fused, encoders, dropout, head
  14. [14] § Materials and Methods › Prediction ↔ Notebooks/model.py, lines 492–624 · score 0.57 · LayerNorm, GELU, fused, encoders, dropout, head
  15. [15] § Materials and Methods › Molecular representation and embedding › Molecular graph ↔ Notebooks/model.py, lines 204–210 · score 0.57 · formal charge, hybridization, node, aromaticity, atoms, encoded
  16. [16] § Materials and Methods › Loss function ↔ Analysis/SHAP/Train.py, lines 256–392 · score 0.54 · margin ranking loss, focal loss
  17. [17] § Materials and Methods › External evaluation dataset ↔ Notebooks/dataset_scaffold_modelready.py, lines 426–515 · score 0.53 · isomeric SMILES, RDKit, canonical, scaffold
  18. [18] § Materials and Methods › Molecular representation and embedding › Molecular fingerprint ↔ Notebooks/model.py, lines 18–94 · score 0.51 · RDKit, hashing, MACCS, Morgan, linear, fingerprints
  19. [19] § Materials and Methods › Training dataset ↔ Notebooks/predict_colab.ipynb, lines 1–31 · score 0.50 · RDKit, sparse, liver microsomal stability, Cross species, cutoff, CYP

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 1,215 lines · 34 KB · no license · 4 matches

  1. # dataset_scaffold.py
  2. # ============================================================
  3. # Dataset preprocessing for multi-task molecular classification
  4. # - SMILES -> graph
  5. # - dense fingerprints: Morgan / MACCS / RDKit
  6. # - descriptor preprocessing with train-only scaler
  7. # - scaffold-disjoint K-fold with fold-level descriptor scaler
  8. # ============================================================
  10. import os
  11. import random
  12. import time
  13. import numpy as np
  14. import pandas as pd
  16. from typing import Optional, List, Dict, Tuple
  17. from collections import defaultdict, Counter
  19. import torch
  20. from torch_geometric.data import InMemoryDataset, Data
  21. from torch_geometric.loader import DataLoader as GeometricDataLoader
  23. from tqdm import tqdm
  25. from sklearn.preprocessing import StandardScaler
  27. from rdkit import Chem
  28. from rdkit.Chem import MACCSkeys
  29. from rdkit.Chem.Scaffolds import MurckoScaffold
  30. from rdkit import DataStructs
  31. from rdkit.Chem.rdFingerprintGenerator import (
  32. GetMorganGenerator,
  33. GetRDKitFPGenerator,
  34. )
  37. # ============================================================
  38. # 1. SMILES sequence encoding
  39. # ============================================================
  41. smi_to_seq = "(.02468@BDFHLNPRTVZ/bdfhlnprt#*%)+-/13579=ACEGIKMOSUWY[]acegimosuy\\"
  42. seq_dict_smi = {ch: (i + 1) for i, ch in enumerate(smi_to_seq)}
  43. MAX_SEQ_SMI_LEN = 100
  46. def seq_smi(smile: str, max_seq_smi_len: int = MAX_SEQ_SMI_LEN) -> np.ndarray:
  47. idx = np.array(
  48. [seq_dict_smi.get(ch, 0) for ch in str(smile)[:max_seq_smi_len]],
  49. dtype=int,
  50. )
  52. if len(idx) < max_seq_smi_len:
  53. idx = np.pad(
  54. idx,
  55. (0, max_seq_smi_len - len(idx)),
  56. "constant",
  57. constant_values=0,
  58. )
  60. return idx
  63. # ============================================================
  64. # 2. Fingerprint generators
  65. # ============================================================
  67. MORGAN_GEN = GetMorganGenerator(radius=2, fpSize=2048)
  68. RDK_GEN = GetRDKitFPGenerator(fpSize=2048)
  71. # ============================================================
  72. # 3. Descriptor settings
  73. # ============================================================
  75. USE_EXPLICIT_COLS = True
  77. PHYS_COLS = [
  78. "MW", "TPSA", "iLOGP", "XLOGP3", "WLOGP", "MLOGP",
  79. "Silicos-IT Log P", "Consensus Log P",
  80. "ESOL Log S", "Ali Log S", "Silicos-IT LogSw",
  81. "#Heavy atoms", "#Aromatic heavy atoms", "Fraction Csp3",
  82. "#Rotatable bonds", "#H-bond acceptors", "#H-bond donors",
  83. "MR", "log Kp (cm/s)",
  84. ]
  86. CONT_COLS = [
  87. "Lipinski #violations", "Ghose #violations", "Veber #violations",
  88. "Egan #violations", "Muegge #violations", "Bioavailability Score",
  89. "PAINS #alerts", "Brenk #alerts", "Leadlikeness #violations",
  90. "Synthetic Accessibility",
  91. ]
  93. CAT_COLS = [
  94. "ESOL Class", "Ali Class", "Silicos-IT class",
  95. "GI absorption", "BBB permeant", "Pgp substrate",
  96. "CYP1A2 inhibitor", "CYP2C19 inhibitor",
  97. "CYP2C9 inhibitor", "CYP2D6 inhibitor", "CYP3A4 inhibitor",
  98. ]
  100. BINARY_POSITIVE_MAP = {
  101. "GI absorption": "High",
  102. "BBB permeant": "Yes",
  103. "Pgp substrate": "Yes",
  104. "CYP1A2 inhibitor": "Yes",
  105. "CYP2C19 inhibitor": "Yes",
  106. "CYP2C9 inhibitor": "Yes",
  107. "CYP2D6 inhibitor": "Yes",
  108. "CYP3A4 inhibitor": "Yes",
  109. }
  112. def _coerce_numeric_series(s: pd.Series) -> pd.Series:
  113. return pd.to_numeric(
  114. s.astype(str).str.replace(",", "", regex=False).str.strip(),
  115. errors="coerce",
  116. )
  119. def _make_desc_df_raw(df_: pd.DataFrame, tasks: List[str]) -> pd.DataFrame:
  120. """
  121. Build the descriptor subset in raw form.
  122. No NaN/Inf imputation or scaling is done here.
  123. """
  125. exclude = set(
  126. [
  127. "Cano_Smile",
  128. "SMILES",
  129. "PUBCHEM_EXT_DATASOURCE_SMILES",
  130. "_canonical_smiles",
  131. ]
  132. + list(tasks)
  133. )
  135. if USE_EXPLICIT_COLS:
  136. phys_in = [c for c in PHYS_COLS if c in df_.columns and c not in exclude]
  137. cont_in = [c for c in CONT_COLS if c in df_.columns and c not in exclude]
  138. cat_in = [c for c in CAT_COLS if c in df_.columns and c not in exclude]
  140. # numeric descriptors
  141. if phys_in or cont_in:
  142. num_df = df_[phys_in + cont_in].copy()
  143. for c in num_df.columns:
  144. num_df[c] = _coerce_numeric_series(num_df[c])
  145. else:
  146. num_df = pd.DataFrame(index=df_.index)
  148. # categorical descriptors
  149. if cat_in:
  150. cat_cols = []
  152. for c in cat_in:
  153. col = df_[c].astype(str).str.strip()
  154. col = col.replace({"nan": np.nan, "None": np.nan, "": np.nan})
  156. uniq = sorted([u for u in col.dropna().unique()])
  158. if 0 < len(uniq) <= 2:
  159. positive = BINARY_POSITIVE_MAP.get(c, uniq[-1])
  160. bin_series = (col == positive).astype(float)
  161. bin_series = bin_series.fillna(0.0)
  162. bin_series.name = f"{c}__{positive}"
  163. cat_cols.append(bin_series)
  164. else:
  165. dummies = pd.get_dummies(col, prefix=c, dummy_na=False)
  166. cat_cols.append(dummies)
  168. cat_df = pd.concat(cat_cols, axis=1)
  169. else:
  170. cat_df = pd.DataFrame(index=df_.index)
  172. desc_df = pd.concat([num_df, cat_df], axis=1)
  174. else:
  175. candidate_numeric_cols = []
  177. for c in df_.columns:
  178. if c in exclude:
  179. continue
  181. coerced = _coerce_numeric_series(df_[c])
  182. if coerced.notna().mean() > 0.9:
  183. candidate_numeric_cols.append(c)
  185. if candidate_numeric_cols:
  186. desc_df = df_[candidate_numeric_cols].copy()
  187. for c in desc_df.columns:
  188. desc_df[c] = _coerce_numeric_series(desc_df[c])
  189. else:
  190. desc_df = pd.DataFrame(index=df_.index)
  192. if desc_df.shape[1] == 0:
  193. desc_df = pd.DataFrame(
  194. {"__desc_dummy__": np.zeros(len(df_), dtype=float)},
  195. index=df_.index,
  196. )
  198. return desc_df
  201. def build_desc_df_scaled(
  202. df: pd.DataFrame,
  203. tasks: List[str],
  204. logger=None,
  205. fixed_cols: Optional[List[str]] = None,
  206. scaler: Optional[StandardScaler] = None,
  207. impute_values: Optional[Dict[str, float]] = None,
  208. add_missing_indicators: bool = True,
  209. ):
  210. """
  211. Descriptor preprocessing.
  213. Train:
  214. fixed_cols=None, scaler=None, impute_values=None
  215. -> build columns, compute medians, fit StandardScaler
  217. Val/Test/External:
  218. fixed_cols=train_cols, scaler=train_scaler, impute_values=train_impute
  219. -> reindex to train schema, impute with train medians, transform with train scaler
  220. """
  222. desc_df_raw = _make_desc_df_raw(df, tasks)
  224. numeric_base_cols = [
  225. c for c in desc_df_raw.columns
  226. if c in set(PHYS_COLS + CONT_COLS)
  227. ]
  229. desc_df_proc = desc_df_raw.replace([np.inf, -np.inf], np.nan)
  231. if add_missing_indicators:
  232. for c in numeric_base_cols:
  233. miss_col = f"{c}__missing"
  234. desc_df_proc[miss_col] = desc_df_proc[c].isna().astype(float)
  236. if fixed_cols is None:
  237. cols = list(desc_df_proc.columns)
  238. else:
  239. for c in fixed_cols:
  240. if c not in desc_df_proc.columns:
  241. desc_df_proc[c] = 0.0
  243. desc_df_proc = desc_df_proc.reindex(columns=fixed_cols)
  244. cols = list(fixed_cols)
  246. if impute_values is None:
  247. impute_values = {}
  249. for c in cols:
  250. med = desc_df_proc[c].median()
  252. if pd.isna(med):
  253. med = 0.0
  255. impute_values[c] = float(med)
  256. else:
  257. impute_values = dict(impute_values)
  259. for c in cols:
  260. desc_df_proc[c] = desc_df_proc[c].fillna(impute_values.get(c, 0.0))
  262. X = desc_df_proc.values.astype("float32")
  264. if scaler is None:
  265. scaler = StandardScaler()
  266. X_scaled = scaler.fit_transform(X)
  267. else:
  268. X_scaled = scaler.transform(X)
  270. desc_df_scaled = pd.DataFrame(
  271. X_scaled,
  272. columns=cols,
  273. index=df.index,
  274. )
  276. if logger:
  277. n_missing_indicators = sum(c.endswith("__missing") for c in cols)
  278. logger.info(
  279. f"[Descriptor] cols={desc_df_scaled.shape[1]} | "
  280. f"missing_indicators={n_missing_indicators} | "
  281. f"fit_scaler={scaler is not None and fixed_cols is None}"
  282. )
  284. return desc_df_scaled, cols, scaler, impute_values
  287. # ============================================================
  288. # 4. Graph feature encoding
  289. # ============================================================
  291. def one_of_k_encoding_unk(x, allowable_set):
  292. if x not in allowable_set:
  293. x = allowable_set[-1]
  294. return [x == s for s in allowable_set]
  297. def _explicit_valence(atom):
  298. if hasattr(Chem, "ValenceType"):
  299. return atom.GetValence(Chem.ValenceType.EXPLICIT)
  300. return atom.GetExplicitValence()
  303. # NOTE:
  304. # To stay compatible with DEFAULT_NODE_IN_DIM=89 in model.py,
  305. # the atom list dim is kept; if you shrink the element list here, update model.py too.
  306. ATOM_LIST = [
  307. "C", "N", "O", "S", "F", "Si", "P", "Cl", "Br", "Mg",
  308. "Na", "Ca", "Fe", "As", "Al", "I", "B", "V", "K", "Tl",
  309. "Yb", "Sb", "Sn", "Ag", "Pd", "Co", "Se", "Ti", "Zn", "H",
  310. "Li", "Ge", "Cu", "Au", "Ni", "Cd", "In", "Mn", "Zr", "Cr",
  311. "Pt", "Hg", "Pb", "Nd", "Ru", "W", "Unknown", "Mo", "Sr",
  312. "Bi", "S", "Ba", "Be", "Dy",
  313. ]
  315. DEGREE_LIST = [0, 1, 2, 3, 4, 5, 6]
  316. FORMAL_CHARGE_LIST = [-1, 0, 1]
  317. EXPLICIT_VALENCE_LIST = [0, 1, 2, 3, 4, 5, 6]
  318. NUM_H_LIST = [0, 1, 2, 3, 4, 5]
  319. HYBRIDIZATION_LIST = [
  320. Chem.rdchem.HybridizationType.SP,
  321. Chem.rdchem.HybridizationType.SP2,
  322. Chem.rdchem.HybridizationType.SP3,
  323. Chem.rdchem.HybridizationType.SP3D,
  324. Chem.rdchem.HybridizationType.SP3D2,
  325. "UNSPECIFIED",
  326. "S",
  327. ]
  328. CHIRALITY_LIST = [
  329. Chem.rdchem.ChiralType.CHI_UNSPECIFIED,
  330. Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CW,
  331. Chem.rdchem.ChiralType.CHI_TETRAHEDRAL_CCW,
  332. Chem.rdchem.ChiralType.CHI_OTHER,
  333. ]
  336. def atom_features(atom):
  337. features = (
  338. one_of_k_encoding_unk(atom.GetSymbol(), ATOM_LIST)
  339. + one_of_k_encoding_unk(atom.GetDegree(), DEGREE_LIST)
  340. + one_of_k_encoding_unk(atom.GetFormalCharge(), FORMAL_CHARGE_LIST)
  341. + one_of_k_encoding_unk(_explicit_valence(atom), EXPLICIT_VALENCE_LIST)
  342. + one_of_k_encoding_unk(atom.GetTotalNumHs(), NUM_H_LIST)
  343. + one_of_k_encoding_unk(atom.GetHybridization(), HYBRIDIZATION_LIST)
  344. + [atom.GetIsAromatic()]
  345. + one_of_k_encoding_unk(atom.GetChiralTag(), CHIRALITY_LIST)
  346. )
  348. return np.array(features, dtype=float)
  351. def bond_features(bond):
  352. bt = bond.GetBondType()
  354. return np.array(
  355. [
  356. bt == Chem.rdchem.BondType.SINGLE,
  357. bt == Chem.rdchem.BondType.DOUBLE,
  358. bt == Chem.rdchem.BondType.TRIPLE,
  359. bt == Chem.rdchem.BondType.AROMATIC,
  360. bond.GetIsConjugated(),
  361. bond.IsInRing(),
  362. ],
  363. dtype=float,
  364. )
  367. # ============================================================
  368. # 5. CSV and Data conversion helpers
  369. # ============================================================
  371. SMI_CANDIDATES = ["Cano_Smile", "SMILES", "PUBCHEM_EXT_DATASOURCE_SMILES"]
  374. def find_smiles_column(df: pd.DataFrame) -> str:
  375. smi_col = next((c for c in SMI_CANDIDATES if c in df.columns), None)
  377. if smi_col is None:
  378. raise ValueError(f"Input CSV must contain one of {SMI_CANDIDATES}")
  380. return smi_col
  383. def prepare_dataframe(
  384. dataset_path: str,
  385. tasks: List[str],
  386. logger=None,
  387. ) -> Tuple[pd.DataFrame, str]:
  388. df = pd.read_csv(dataset_path)
  389. smi_col = find_smiles_column(df)
  391. for t in tasks:
  392. if t not in df.columns:
  393. df[t] = -1
  394. df[t] = _coerce_numeric_series(df[t]).fillna(-1).astype(np.float32)
  396. label_mat = df[tasks].values
  397. valid_label_mask = (label_mat != -1).any(axis=1)
  398. df = df[valid_label_mask].reset_index(drop=True)
  400. canonical_smiles = []
  401. keep_idx = []
  402. invalid_smiles = 0
  404. for idx, smi in enumerate(df[smi_col].astype(str)):
  405. mol = Chem.MolFromSmiles(smi.strip())
  407. if mol is None:
  408. invalid_smiles += 1
  409. continue
  411. canonical_smiles.append(Chem.MolToSmiles(mol, isomericSmiles=True))
  412. keep_idx.append(idx)
  414. df = df.iloc[keep_idx].reset_index(drop=True)
  415. df["_canonical_smiles"] = canonical_smiles
  417. if logger:
  418. logger.info(
  419. f"[prepare_dataframe] {os.path.basename(dataset_path)} | "
  420. f"kept={len(df)} | invalid_smiles={invalid_smiles}"
  421. )
  423. return df, "_canonical_smiles"
  426. def dataframe_to_data_list(
  427. df: pd.DataFrame,
  428. tasks: List[str],
  429. desc_df: pd.DataFrame,
  430. smi_col: str,
  431. logger=None,
  432. ):
  433. data_list = []
  434. smiles_attr = []
  435. invalid_smiles = 0
  437. for i, row in tqdm(
  438. df.iterrows(),
  439. total=len(df),
  440. desc="Graph Conversion",
  441. ):
  442. smi = str(row[smi_col]).strip()
  443. mol = Chem.MolFromSmiles(smi)
  445. if mol is None:
  446. invalid_smiles += 1
  447. continue
  449. canonical_smi = Chem.MolToSmiles(mol, isomericSmiles=True)
  451. atom_feat = [atom_features(atom) for atom in mol.GetAtoms()]
  452. x = torch.tensor(np.array(atom_feat), dtype=torch.float)
  454. edge_indices = []
  455. edge_attrs = []
  457. for bond in mol.GetBonds():
  458. start = bond.GetBeginAtomIdx()
  459. end = bond.GetEndAtomIdx()
  460. b_feat = bond_features(bond)
  462. edge_indices.append([start, end])
  463. edge_attrs.append(b_feat)
  464. edge_indices.append([end, start])
  465. edge_attrs.append(b_feat)
  467. if len(edge_indices) == 0:
  468. edge_index = torch.empty((2, 0), dtype=torch.long)
  469. edge_attr = torch.empty((0, 6), dtype=torch.float)
  470. else:
  471. edge_index = torch.tensor(edge_indices, dtype=torch.long).t().contiguous()
  472. edge_attr = torch.tensor(np.array(edge_attrs), dtype=torch.float)
  474. data = Data(x=x, edge_index=edge_index, edge_attr=edge_attr)
  475. data.smiles = canonical_smi
  477. # Morgan / RDKit hashed fingerprints
  478. for gen, name in [(MORGAN_GEN, "morgan_fp"), (RDK_GEN, "rdit_fp")]:
  479. bv = gen.GetFingerprint(mol)
  480. arr = np.zeros((bv.GetNumBits(),), dtype=np.int8)
  481. DataStructs.ConvertToNumpyArray(bv, arr)
  482. setattr(
  483. data,
  484. name,
  485. torch.from_numpy(arr.astype(np.float32)).unsqueeze(0),
  486. )
  488. # MACCS
  489. bv_maccs = MACCSkeys.GenMACCSKeys(mol)
  490. arr_maccs = np.zeros((bv_maccs.GetNumBits(),), dtype=np.int8)
  491. DataStructs.ConvertToNumpyArray(bv_maccs, arr_maccs)
  492. data.maccs_fp = torch.from_numpy(arr_maccs.astype(np.float32)).unsqueeze(0)
  494. data.y = torch.tensor(
  495. row[tasks].values.astype(np.float32),
  496. dtype=torch.float,
  497. ).unsqueeze(0)
  499. data.desc = torch.tensor(
  500. desc_df.iloc[i].values.astype(np.float32),
  501. dtype=torch.float,
  502. ).unsqueeze(0)
  504. data.smil2vec = torch.LongTensor(seq_smi(canonical_smi)).unsqueeze(0)
  506. data_list.append(data)
  507. smiles_attr.append(canonical_smi)
  509. if logger:
  510. logger.info(
  511. f"[dataframe_to_data_list] valid={len(data_list)} | "
  512. f"invalid_smiles={invalid_smiles}"
  513. )
  515. return data_list, smiles_attr
  518. # ============================================================
  519. # 6. Safe torch load
  520. # ============================================================
  522. def _safe_torch_load(path: str):
  523. try:
  524. return torch.load(path, map_location="cpu", weights_only=False)
  525. except TypeError:
  526. return torch.load(path, map_location="cpu")
  529. # ============================================================
  530. # 7. MolDataset
  531. # ============================================================
  533. class MolDataset(InMemoryDataset):
  534. def __init__(
  535. self,
  536. root,
  537. dataset,
  538. task_type,
  539. tasks,
  540. logger=None,
  541. transform=None,
  542. pre_transform=None,
  543. pre_filter=None,
  544. desc_cols=None,
  545. desc_scaler=None,
  546. desc_impute_values=None,
  547. processed_suffix="default",
  548. ):
  549. self.tasks = tasks
  550. self.dataset = dataset
  551. self.task_type = task_type
  552. self.logger = logger
  554. self.fixed_desc_cols = desc_cols
  555. self.fixed_desc_scaler = desc_scaler
  556. self.fixed_desc_impute_values = desc_impute_values
  557. self.processed_suffix = processed_suffix
  559. super().__init__(root, transform, pre_transform, pre_filter)
  561. loaded = _safe_torch_load(self.processed_paths[0])
  563. if isinstance(loaded, tuple) and len(loaded) == 6:
  564. (
  565. self.data,
  566. self.slices,
  567. self.smiles_list,
  568. self.desc_cols_,
  569. self.desc_scaler_,
  570. self.desc_impute_values_,
  571. ) = loaded
  573. elif isinstance(loaded, tuple) and len(loaded) == 5:
  574. (
  575. self.data,
  576. self.slices,
  577. self.smiles_list,
  578. self.desc_cols_,
  579. self.desc_scaler_,
  580. ) = loaded
  581. self.desc_impute_values_ = None
  583. else:
  584. self.data, self.slices, self.smiles_list = loaded[:3]
  585. self.desc_cols_ = None
  586. self.desc_scaler_ = None
  587. self.desc_impute_values_ = None
  589. @property
  590. def raw_file_names(self):
  591. return [self.dataset]
  593. @property
  594. def processed_file_names(self):
  595. base = os.path.splitext(os.path.basename(self.dataset))[0]
  596. return [f"{base}_{self.processed_suffix}.pt"]
  598. def process(self):
  599. dataset_path = os.path.join(self.root, self.dataset)
  601. df, smi_col = prepare_dataframe(
  602. dataset_path=dataset_path,
  603. tasks=self.tasks,
  604. logger=self.logger,
  605. )
  607. desc_df, used_cols, scaler, impute_values = build_desc_df_scaled(
  608. df,
  609. tasks=self.tasks,
  610. logger=self.logger,
  611. fixed_cols=self.fixed_desc_cols,
  612. scaler=self.fixed_desc_scaler,
  613. impute_values=self.fixed_desc_impute_values,
  614. )
  616. self.desc_cols_ = list(used_cols)
  617. self.desc_scaler_ = scaler
  618. self.desc_impute_values_ = impute_values
  620. data_list, smiles_attr = dataframe_to_data_list(
  621. df=df,
  622. tasks=self.tasks,
  623. desc_df=desc_df,
  624. smi_col=smi_col,
  625. logger=self.logger,
  626. )
  628. if len(data_list) == 0:
  629. raise RuntimeError(f"[MolDataset] No valid molecules found in {self.dataset}")
  631. data, slices = self.collate(data_list)
  633. torch.save(
  634. (
  635. data,
  636. slices,
  637. smiles_attr,
  638. self.desc_cols_,
  639. self.desc_scaler_,
  640. self.desc_impute_values_,
  641. ),
  642. self.processed_paths[0],
  643. )
  646. # ============================================================
  647. # 8. Scaffold split utilities
  648. # ============================================================
  650. def _murcko_scaffold(smi: str, include_chirality: bool = False) -> str:
  651. try:
  652. mol = Chem.MolFromSmiles(smi)
  654. if mol is None:
  655. return ""
  657. return MurckoScaffold.MurckoScaffoldSmiles(
  658. mol=mol,
  659. includeChirality=include_chirality,
  660. ) or ""
  662. except Exception:
  663. return ""
  666. def _group_indices_by_scaffold(
  667. smiles_list: List[str],
  668. include_chirality: bool = False,
  669. ):
  670. buckets = defaultdict(list)
  672. for i, smi in enumerate(smiles_list):
  673. scaf = _murcko_scaffold(smi, include_chirality=include_chirality)
  674. key = scaf if len(scaf) > 0 else smi
  675. buckets[key].append(i)
  677. return buckets
  680. def _greedy_pack_scaffolds_to_folds(
  681. scaffold_buckets: Dict[str, List[int]],
  682. n_splits: int,
  683. seed: int = 2026,
  684. ):
  685. groups = list(scaffold_buckets.items())
  686. groups.sort(key=lambda kv: (-len(kv[1]), kv[0]))
  688. fold_bins = [[] for _ in range(n_splits)]
  689. fold_sizes = [0] * n_splits
  691. for _, idx_list in groups:
  692. k = min(range(n_splits), key=lambda f: fold_sizes[f])
  693. fold_bins[k].extend(idx_list)
  694. fold_sizes[k] += len(idx_list)
  696. return fold_bins
  699. def _log_fold_stats(data_list, tasks, logger, tag=""):
  700. if not logger:
  701. return
  703. cnt = Counter()
  704. pos_cnt = Counter()
  705. neg_cnt = Counter()
  707. for d in data_list:
  708. yrow = d.y.view(-1)
  710. for i, t in enumerate(tasks):
  711. val = yrow[i].item()
  713. if val != -1:
  714. cnt[t] += 1
  716. if val == 1:
  717. pos_cnt[t] += 1
  718. elif val == 0:
  719. neg_cnt[t] += 1
  721. logger.info(
  722. f"{tag} size={len(data_list)} | "
  723. f"available={dict(cnt)} | "
  724. f"pos={dict(pos_cnt)} | "
  725. f"neg={dict(neg_cnt)}"
  726. )
  729. # ============================================================
  730. # 9. Scaffold K-fold loader with fold-level descriptor scaler
  731. # ============================================================
  732. import hashlib
  733. import json
  736. def _safe_torch_load_cache(path: str):
  737. try:
  738. return torch.load(path, map_location="cpu", weights_only=False)
  739. except TypeError:
  740. return torch.load(path, map_location="cpu")
  743. def _make_fold_cache_path(
  744. data_path,
  745. dataset_name,
  746. tasks,
  747. n_splits,
  748. include_chirality,
  749. seed,
  750. cache_dir=None,
  751. cache_version="v1",
  752. ):
  753. """
  754. Build the per-fold graph/data_list cache path.
  755. Includes dataset file size/mtime, so a changed CSV automatically uses a different cache.
  756. """
  758. dataset_path = os.path.join(data_path, dataset_name)
  760. if not os.path.exists(dataset_path):
  761. raise FileNotFoundError(dataset_path)
  763. stat = os.stat(dataset_path)
  765. meta = {
  766. "dataset_name": dataset_name,
  767. "tasks": list(tasks),
  768. "n_splits": int(n_splits),
  769. "include_chirality": bool(include_chirality),
  770. "seed": int(seed),
  771. "file_size": int(stat.st_size),
  772. "file_mtime": int(stat.st_mtime),
  773. "cache_version": str(cache_version),
  774. }
  776. key = hashlib.md5(
  777. json.dumps(meta, sort_keys=True).encode("utf-8")
  778. ).hexdigest()[:12]
  780. if cache_dir is None:
  781. cache_dir = os.path.join(data_path, "fold_graph_cache")
  783. os.makedirs(cache_dir, exist_ok=True)
  785. base = os.path.splitext(os.path.basename(dataset_name))[0]
  786. cache_path = os.path.join(
  787. cache_dir,
  788. f"{base}_scaffold{n_splits}_seed{seed}_{key}.pt",
  789. )
  791. return cache_path, meta
  794. def _build_loaders_from_cached_fold_lists(
  795. cached_train_lists,
  796. cached_val_lists,
  797. batch_size,
  798. ):
  799. train_loaders = []
  800. val_loaders = []
  802. for train_data_list, val_data_list in zip(cached_train_lists, cached_val_lists):
  803. train_loader = GeometricDataLoader(
  804. train_data_list,
  805. batch_size=batch_size,
  806. shuffle=True,
  807. num_workers=0,
  808. drop_last=False,
  809. )
  811. val_loader = GeometricDataLoader(
  812. val_data_list,
  813. batch_size=batch_size,
  814. shuffle=False,
  815. num_workers=0,
  816. drop_last=False,
  817. )
  819. train_loaders.append(train_loader)
  820. val_loaders.append(val_loader)
  822. return train_loaders, val_loaders
  823. def build_scaffold_kfold_loader(
  824. data_path: str,
  825. dataset_name: str,
  826. task_type: str,
  827. batch_size: int,
  828. tasks: List[str],
  829. logger=None,
  830. n_splits: int = 10,
  831. include_chirality: bool = False,
  832. seed: int = 2026,
  833. use_cache: bool = True,
  834. force_rebuild: bool = False,
  835. cache_dir: str = None,
  836. cache_version: str = "v1",
  837. ):
  838. """
  839. Scaffold K-fold loader with fold-level descriptor scaler + fold graph cache.
  841. First run:
  842. raw CSV -> scaffold split -> per-fold descriptor scaler fit/transform
  843. -> graph conversion -> save fold cache
  845. Subsequent runs:
  846. load fold cache -> build DataLoader
  848. Returns
  849. -------
  850. train_loaders : list[DataLoader]
  851. val_loaders : list[DataLoader]
  852. fold_desc_info: list[dict]
  853. """
  855. random.seed(seed)
  856. np.random.seed(seed)
  857. torch.manual_seed(seed)
  859. # --------------------------------------------------------
  860. # 0. build cache path
  861. # --------------------------------------------------------
  862. cache_path, cache_meta = _make_fold_cache_path(
  863. data_path=data_path,
  864. dataset_name=dataset_name,
  865. tasks=tasks,
  866. n_splits=n_splits,
  867. include_chirality=include_chirality,
  868. seed=seed,
  869. cache_dir=cache_dir,
  870. cache_version=cache_version,
  871. )
  873. # --------------------------------------------------------
  874. # 1. Cache load
  875. # --------------------------------------------------------
  876. if use_cache and (not force_rebuild) and os.path.exists(cache_path):
  877. if logger:
  878. logger.info("=" * 70)
  879. logger.info(f"[Scaffold Cache] Loading cached folds:")
  880. logger.info(f" {cache_path}")
  881. logger.info("=" * 70)
  883. payload = _safe_torch_load_cache(cache_path)
  885. cached_train_lists = payload["train_data_lists"]
  886. cached_val_lists = payload["val_data_lists"]
  887. fold_desc_info = payload["fold_desc_info"]
  889. train_loaders, val_loaders = _build_loaders_from_cached_fold_lists(
  890. cached_train_lists=cached_train_lists,
  891. cached_val_lists=cached_val_lists,
  892. batch_size=batch_size,
  893. )
  895. if logger:
  896. logger.info(
  897. f"[Scaffold Cache] Loaded {len(train_loaders)} folds from cache."
  898. )
  900. for fold_idx, (tr_list, va_list) in enumerate(
  901. zip(cached_train_lists, cached_val_lists)
  902. ):
  903. logger.info(
  904. f"[Cached Fold {fold_idx + 1}/{len(train_loaders)}] "
  905. f"Train={len(tr_list)}, Val={len(va_list)}"
  906. )
  907. _log_fold_stats(tr_list, tasks, logger, tag=" Train")
  908. _log_fold_stats(va_list, tasks, logger, tag=" Val ")
  910. return train_loaders, val_loaders, fold_desc_info
  912. # --------------------------------------------------------
  913. # 2. build fresh if no cache
  914. # --------------------------------------------------------
  915. if logger:
  916. logger.info("=" * 70)
  917. logger.info("[Scaffold Cache] Cache not found or force_rebuild=True.")
  918. logger.info("[Scaffold Cache] Building folds from raw CSV.")
  919. logger.info(f"[Scaffold Cache] Cache will be saved to: {cache_path}")
  920. logger.info("=" * 70)
  922. dataset_path = os.path.join(data_path, dataset_name)
  924. df, smi_col = prepare_dataframe(
  925. dataset_path=dataset_path,
  926. tasks=tasks,
  927. logger=logger,
  928. )
  930. smiles_list = df[smi_col].tolist()
  932. buckets = _group_indices_by_scaffold(
  933. smiles_list,
  934. include_chirality=include_chirality,
  935. )
  937. fold_bins = _greedy_pack_scaffolds_to_folds(
  938. buckets,
  939. n_splits=n_splits,
  940. seed=seed,
  941. )
  943. train_loaders = []
  944. val_loaders = []
  945. fold_desc_info = []
  947. cached_train_lists = []
  948. cached_val_lists = []
  950. # --------------------------------------------------------
  951. # 3. build per-fold data_list
  952. # --------------------------------------------------------
  953. for fold_idx in range(n_splits):
  954. val_index = sorted(fold_bins[fold_idx])
  955. train_index = sorted(
  956. [
  957. i
  958. for k in range(n_splits)
  959. if k != fold_idx
  960. for i in fold_bins[k]
  961. ]
  962. )
  964. train_df = df.iloc[train_index].reset_index(drop=True)
  965. val_df = df.iloc[val_index].reset_index(drop=True)
  967. # fit descriptor scaler on fold-train only
  968. train_desc_df, desc_cols, desc_scaler, desc_impute_values = build_desc_df_scaled(
  969. train_df,
  970. tasks=tasks,
  971. logger=logger,
  972. fixed_cols=None,
  973. scaler=None,
  974. impute_values=None,
  975. )
  977. # transform fold-val with the train scaler
  978. val_desc_df, _, _, _ = build_desc_df_scaled(
  979. val_df,
  980. tasks=tasks,
  981. logger=logger,
  982. fixed_cols=desc_cols,
  983. scaler=desc_scaler,
  984. impute_values=desc_impute_values,
  985. )
  987. train_data_list, _ = dataframe_to_data_list(
  988. df=train_df,
  989. tasks=tasks,
  990. desc_df=train_desc_df,
  991. smi_col=smi_col,
  992. logger=logger,
  993. )
  995. val_data_list, _ = dataframe_to_data_list(
  996. df=val_df,
  997. tasks=tasks,
  998. desc_df=val_desc_df,
  999. smi_col=smi_col,
  1000. logger=logger,
  1001. )
  1003. train_loader = GeometricDataLoader(
  1004. train_data_list,
  1005. batch_size=batch_size,
  1006. shuffle=True,
  1007. num_workers=0,
  1008. drop_last=False,
  1009. )
  1011. val_loader = GeometricDataLoader(
  1012. val_data_list,
  1013. batch_size=batch_size,
  1014. shuffle=False,
  1015. num_workers=0,
  1016. drop_last=False,
  1017. )
  1019. if logger:
  1020. logger.info(
  1021. f"[Scaffold Fold {fold_idx + 1}/{n_splits}] "
  1022. f"Train={len(train_data_list)}, Val={len(val_data_list)}"
  1023. )
  1024. _log_fold_stats(train_data_list, tasks, logger, tag=" Train")
  1025. _log_fold_stats(val_data_list, tasks, logger, tag=" Val ")
  1027. train_loaders.append(train_loader)
  1028. val_loaders.append(val_loader)
  1030. cached_train_lists.append(train_data_list)
  1031. cached_val_lists.append(val_data_list)
  1033. fold_desc_info.append(
  1034. {
  1035. "desc_cols": desc_cols,
  1036. "desc_scaler": desc_scaler,
  1037. "desc_impute_values": desc_impute_values,
  1038. "train_index": train_index,
  1039. "val_index": val_index,
  1040. }
  1041. )
  1043. # --------------------------------------------------------
  1044. # 4. Save cache
  1045. # --------------------------------------------------------
  1046. if use_cache:
  1047. payload = {
  1048. "meta": cache_meta,
  1049. "train_data_lists": cached_train_lists,
  1050. "val_data_lists": cached_val_lists,
  1051. "fold_desc_info": fold_desc_info,
  1052. }
  1054. torch.save(payload, cache_path)
  1056. if logger:
  1057. logger.info("=" * 70)
  1058. logger.info(f"[Scaffold Cache] Saved fold cache:")
  1059. logger.info(f" {cache_path}")
  1060. logger.info("=" * 70)
  1062. return train_loaders, val_loaders, fold_desc_info
  1063. # ============================================================
  1064. # 10. Standard train/val/test loader
  1065. # ============================================================
  1067. def build_loader(
  1068. data_path,
  1069. dataset_names,
  1070. task_type,
  1071. batch_size,
  1072. tasks,
  1073. logger=None,
  1074. ):
  1075. train_loader = None
  1076. val_loader = None
  1077. test_loader = None
  1079. train_desc_cols = None
  1080. train_desc_scaler = None
  1081. train_desc_impute_values = None
  1083. if "train" in dataset_names:
  1084. train_dataset = MolDataset(
  1085. root=data_path,
  1086. dataset=dataset_names["train"],
  1087. task_type=task_type,
  1088. tasks=tasks,
  1089. logger=logger,
  1090. desc_cols=None,
  1091. desc_scaler=None,
  1092. desc_impute_values=None,
  1093. processed_suffix="train_fit",
  1094. )
  1096. train_desc_cols = getattr(train_dataset, "desc_cols_", None)
  1097. train_desc_scaler = getattr(train_dataset, "desc_scaler_", None)
  1098. train_desc_impute_values = getattr(train_dataset, "desc_impute_values_", None)
  1100. train_loader = GeometricDataLoader(
  1101. train_dataset,
  1102. batch_size=batch_size,
  1103. shuffle=True,
  1104. num_workers=0,
  1105. drop_last=False,
  1106. )
  1108. if "val" in dataset_names:
  1109. val_dataset = MolDataset(
  1110. root=data_path,
  1111. dataset=dataset_names["val"],
  1112. task_type=task_type,
  1113. tasks=tasks,
  1114. logger=logger,
  1115. desc_cols=train_desc_cols,
  1116. desc_scaler=train_desc_scaler,
  1117. desc_impute_values=train_desc_impute_values,
  1118. processed_suffix="val_using_train_scaler",
  1119. )
  1121. val_loader = GeometricDataLoader(
  1122. val_dataset,
  1123. batch_size=batch_size,
  1124. shuffle=False,
  1125. num_workers=0,
  1126. drop_last=False,
  1127. )
  1129. if "test" in dataset_names:
  1130. test_dataset = MolDataset(
  1131. root=data_path,
  1132. dataset=dataset_names["test"],
  1133. task_type=task_type,
  1134. tasks=tasks,
  1135. logger=logger,
  1136. desc_cols=train_desc_cols,
  1137. desc_scaler=train_desc_scaler,
  1138. desc_impute_values=train_desc_impute_values,
  1139. processed_suffix="test_using_train_scaler",
  1140. )
  1142. test_loader = GeometricDataLoader(
  1143. test_dataset,
  1144. batch_size=batch_size,
  1145. shuffle=False,
  1146. num_workers=0,
  1147. drop_last=False,
  1148. )
  1150. return (
  1151. train_loader,
  1152. val_loader,
  1153. test_loader,
  1154. train_desc_cols,
  1155. train_desc_scaler,
  1156. train_desc_impute_values,
  1157. )
  1160. # ============================================================
  1161. # 11. External loader
  1162. # ============================================================
  1164. def build_external_loader(
  1165. data_path,
  1166. dataset_name,
  1167. task_type,
  1168. batch_size,
  1169. tasks,
  1170. logger,
  1171. train_desc_cols,
  1172. train_desc_scaler,
  1173. train_desc_impute_values,
  1174. processed_suffix="external_using_train_scaler",
  1175. ):
  1176. """
  1177. External HLM/RLM test loader.
  1179. You must pass the train descriptor schema/scaler/impute_values.
  1180. """
  1182. external_dataset = MolDataset(
  1183. root=data_path,
  1184. dataset=dataset_name,
  1185. task_type=task_type,
  1186. tasks=tasks,
  1187. logger=logger,
  1188. desc_cols=train_desc_cols,
  1189. desc_scaler=train_desc_scaler,
  1190. desc_impute_values=train_desc_impute_values,
  1191. processed_suffix=processed_suffix,
  1192. )
  1194. external_loader = GeometricDataLoader(
  1195. external_dataset,
  1196. batch_size=batch_size,
  1197. shuffle=False,
  1198. num_workers=0,
  1199. drop_last=False,
  1200. )
  1202. return external_loader
  1205. # ============================================================
  1206. # 12. Quick feature dimension check
  1207. # ============================================================
  1209. def check_atom_feature_dim(smiles: str = "CCO") -> int:
  1210. mol = Chem.MolFromSmiles(smiles)
  1212. if mol is None:
  1213. raise ValueError(f"Invalid SMILES: {smiles}")
  1215. return len(atom_features(mol.GetAtomWithIdx(0)))

dataset_scaffold_modelready.py at commit 2e085d8, no license · at the source

Overview

Authors: Subhin Seomun1, Sunyong Yoo1,2
ORCID iDs: Sunyong Yoo
  1. Department of Intelligent Electronics and Computer Engineering, Chonnam National University, Gwangju, Republic of Korea
  2. R&D Center, MATILO AI Inc., Gwangju, Republic of Korea
Institutions: Chonnam National University (South Korea)
Journal: Computational and structural biotechnology journal, volume 35, issue 1, article 0184
Dates: received 10 May 2026; accepted 13 July 2026; published online 11 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.34133/csbj.0184 · PMID 42582689 · PMCID PMC13457899 · OpenAlex W7168294012
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: cellular / molecular (subfield)
Methods: Statistics, Machine learning, Graphs
Topic: Machine Learning in Bioinformatics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Ministry of Food and Drug Safety (RS-2025-02215961, RS-2024-00332003); Ministry of Science and ICT, South Korea (RS-2025-16063391)
Citations: not cited yet (Europe PMC); 70 references in the paper

Abstract

Liver microsomal metabolic stability is a key determinant of in vivo exposure and an essential filter in lead optimization, yet cross-species prediction remains difficult because of heterogeneous metabolic pathways and limited model interpretability. We propose a cross-species multitask learning framework that integrates complementary molecular modalities—SMILES-derived fingerprints (Morgan and MACCS/RDKit), molecular graphs, and in silico absorption, distribution, metabolism, and excretion (ADME)/physicochemical descriptors—to predict binary microsomal stability (unstable: t1/2 ≤ 30 min; stable: t1/2 > 30 min) in human (HLM), rat (RLM), and mouse (MLM) liver microsomes. We curated 18,921 PubChem BioAssay measurements (6,685 HLM; 5,753 RLM; 6,483 MLM). Under stratified 10-fold Bemis–Murcko scaffold cross-validation with ensemble prediction and species-specific thresholds, the model achieved AUROC values of 0.811, 0.806, and 0.794 and AUPR values of 0.854, 0.860, and 0.862 for HLM, RLM, and MLM, respectively, consistently outperforming conventional machine-learning and single-task deep-learning baselines. SHapley Additive exPlanations (SHAP) identified transport/permeability indicators, CYP interaction flags, and the lipophilicity–polarity axis as the features most strongly associated with predicted stability. EdgeSHAPer, a graph neural network explanation method based on SHAP, highlighted stabilizing and destabilizing substructures. Recurrent destabilizing attributions were observed in alkene and allylic/benzylic contexts, whereas amide/carbamate motifs exhibited stabilizing attributions, with nitriles and halogens showing context-dependent effects. Fragment–ADME enrichment analysis characterized associations between local structural motifs and whole-molecule properties including lipophilicity, solubility, and blood–brain barrier permeability. This multi-modal, cross-species framework demonstrates that integrating structural encodings with ADME descriptors enhances both predictive performance and interpretability, yielding hypothesis-generating attributions for structural optimization that warrant prospective experimental validation.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 19 matches between paragraphs and lines of code.

bmil-jnu/cross-species_metabolic_stability_prediction

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 2e085d8bbc018abac4877a2686f481388ad47d8f, 20 August 2026
Languages: Python (23), Jupyter (2)
Size: 42 files, 25 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, environment (Main/requirements.txt, Notebooks/pyproject.toml, Notebooks/requirements.txt), 2 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (21 files), PyTorch Geometric (15 files), NumPy (14 files), pandas (13 files), RDKit (7 files), scikit-learn (7 files), Matplotlib (6 files), SHAP (4 files), Pillow (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
26 files
At the source: github.com/bmil-jnu/cross-species_metabolic_stability_prediction

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 25 scripts, each with its path and the digest of its content;
  • 19 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability

The model implementation, the trained model, the inference and explanation software, and the preprocessed training and external-validation datasets are available at https://github.com/bmil-jnu/cross-species_metabolic_stability_prediction. A Google Colab notebook for running predictions without local installation is also provided in the repository.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 3, 28 September 2026

  • Funding: added Ministry of Food and Drug Safety: RS-2025-02215961, RS-2024-00332003; Ministry of Science and ICT, South Korea: RS-2025-16063391

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 2 authors, 62 references.

Cite

This paper

Seomun, S., & Yoo, S. (2026). Cross-Species Multitask Learning with Molecular and ADME Descriptors for Liver Microsomal Metabolic Stability. Computational and structural biotechnology journal, 35(1), 0184. https://doi.org/10.34133/csbj.0184

BibTeX

@article{seomun2026cross,
author = {Seomun, Subhin and Yoo, Sunyong},
title = {{Cross-Species Multitask Learning with Molecular and ADME Descriptors for Liver Microsomal Metabolic Stability}},
journal = {Computational and structural biotechnology journal},
year = {2026},
month = aug,
volume = {35},
number = {1},
pages = {0184},
publisher = {AAAS Science Partner Journal Program},
issn = {2001-0370},
doi = {10.34133/csbj.0184},
url = {https://doi.org/10.34133/csbj.0184},
pmid = {42582689},
pmcid = {PMC13457899}
}

RIS

TY - JOUR
AU - Seomun, Subhin
AU - Yoo, Sunyong
TI - Cross-Species Multitask Learning with Molecular and ADME Descriptors for Liver Microsomal Metabolic Stability
T2 - Computational and structural biotechnology journal
J2 - Comput Struct Biotechnol J
PY - 2026
DA - 2026/08/11
VL - 35
IS - 1
SP - 0184
SN - 2001-0370
PB - AAAS Science Partner Journal Program
DO - 10.34133/csbj.0184
UR - https://doi.org/10.34133/csbj.0184
LA - en
ER -

CSL-JSON

{
"id": "10.34133/csbj.0184",
"type": "article-journal",
"title": "Cross-Species Multitask Learning with Molecular and ADME Descriptors for Liver Microsomal Metabolic Stability",
"container-title": "Computational and structural biotechnology journal",
"author": [
{
"family": "Seomun",
"given": "Subhin"
},
{
"family": "Yoo",
"given": "Sunyong"
}
],
"container-title-short": "Comput Struct Biotechnol J",
"volume": "35",
"issue": "1",
"page": "0184",
"DOI": "10.34133/csbj.0184",
"PMID": "42582689",
"PMCID": "PMC13457899",
"ISSN": "2001-0370",
"publisher": "AAAS Science Partner Journal Program",
"URL": "https://doi.org/10.34133/csbj.0184",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
11
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.34133/csbj.0036 [code]
HYG-mol: An Interpretable Multimodal Hypergraph Framework for Molecular Property Prediction.
Journal: Computational and structural biotechnology journal
In common: RDKit, PyTorch Geometric, PyTorch, 4 other tools, cellular / molecular, 3 references
[2] doi:10.1371/journal.pone.0345854 [code]
Shedding light on neural learning to rank models for anticancer drug prioritization.
Journal: PloS one
In common: RDKit, SHAP, PyTorch Geometric, 5 other tools, 1 reference
[3] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: RDKit, SHAP, Pillow, 5 other tools, cellular / molecular
[4] doi:10.1093/bib/bbag118 [code]
Drug screening for α-synuclein aggregation inhibitors via multimodal graph neural network.
Journal: Briefings in bioinformatics
In common: RDKit, PyTorch Geometric, Pillow, 5 other tools, cellular / molecular
[5] doi:10.1093/bioinformatics/btag153 [code]
MAISNet: a multi-species integrated graph neural network for acetylcholinesterase inhibitor screening.
Journal: Bioinformatics (Oxford, England)
In common: RDKit, PyTorch Geometric, PyTorch, 4 other tools, 1 reference
[6] doi:10.1002/pro.70695 [code]
MIF-MAPMS: Enhancing identification of myelin autoantigenic peptides in multiple sclerosis through multimodal information fusion.
Journal: Protein science : a publication of the Protein Society
In common: RDKit, PyTorch, scikit-learn, 3 other tools, cellular / molecular, 2 references
[7] doi:10.3390/ijms27156614 [code]
Candidalysin Inhibits &lt;i&gt;Porphyromonas gingivalis&lt;/i&gt; Lipoprotein-Induced IL-1β Production in BV-2 Microglia via Hydrophobic Microbial Interactions.
Journal: International journal of molecular sciences
In common: RDKit, PyTorch Geometric, PyTorch, 4 other tools, cellular / molecular
[8] doi:10.1038/s41586-026-10670-w [code]
Zero-shot design of drug-binding proteins via neural iterative selection-expansion.
Journal: Nature
In common: RDKit, PyTorch Geometric, PyTorch, 4 other tools, cellular / molecular
[9] doi:10.1038/s41598-026-53415-5 [code]
Computational design and immunoinformatics validation of a T cell multi-epitope vaccine targeting glioblastoma stem cells.
Journal: Scientific reports
In common: RDKit, PyTorch Geometric, PyTorch, 4 other tools, cellular / molecular
[10] doi:10.1038/s41586-026-10391-0 [code]
Cell-type-targeted mitochondrial transplantation rescues cell degeneration.
Journal: Nature
In common: RDKit, PyTorch Geometric, PyTorch, 4 other tools, cellular / molecular

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.