OSCR

Structure-Based and AI-Assisted Identification of AGPS Inhibitors for Glioma via Integrated Docking, Molecular Dynamics, and Binding Affinity Screening.

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] § Methods › Deep Neural Network for Binding Affinity Prediction › Ligand Preprocessing and Pharmacophore Feature Extraction ↔ pharmacophore_modeling.py, lines 223–255 · score 0.95 · aliphatic rings, aromatic rings, rdMolDescriptors, MolLogP, MolWt, NumRotatableBonds
  2. [2] § Methods › AI-Assisted Literature Search for Target Identification ↔ language model.py, lines 18–67 · score 0.91 · FLAN T5 XXL, L6 v2, MiniLM, prompts, FAISS, Sentence
  3. [3] § Methods › Deep Neural Network for Binding Affinity Prediction › Ligand Quantum and Graph Representation ↔ pharmacophore_modeling.py, lines 223–255 · score 0.86 · MolLogP, MolWt, NumRotatableBonds, partial charges, Gasteiger, HBA
  4. [4] § Methods › Hybrid Model Architecture › 3D CNN for Voxelized Spatial Encoding ↔ Binding free energy model.py, lines 300–341 · score 0.81 · BatchNorm3d, Conv3d, ReLU, kernel, CNN, flattened
  5. [5] § Methods › Deep Neural Network for Binding Affinity Prediction › Ligand Quantum and Graph Representation ↔ pharmacophore_modeling.py, lines 177–221 · score 0.76 · AllChem.EmbedMolecule, Chem.AddHs, random seed, graph, optimization, pharmacophoric
  6. [6] § Methods › Model Training and Evaluation ↔ Binding free energy model.py, lines 462–483 · score 0.76 · AdamW, hybrid model, binding free energies, training, batch, Optimization
  7. [7] § Methods › AI-Assisted Literature Search for Target Identification ↔ scoring assistant.py, lines 203–219 · score 0.76 · L6 v2, MiniLM, Sentence, paraphrase, semantic, embedder
  8. [8] § Methods › Deep Neural Network for Binding Affinity Prediction › Deep Graph Neural Network Model ↔ pharmacophore_modeling.py, lines 270–308 · score 0.74 · LeakyReLU, multihead attention, layer normalization, PyTorch, modules, GNN
  9. [9] § Methods › Deep Neural Network for Binding Affinity Prediction › Protein Structure Featurization ↔ pharmacophore_modeling.py, lines 154–175 · score 0.73 · ANM modes, surface points, active site, volume, dummy, hydrophobicity
  10. [10] § Results › Deep Interaction Featurization Using ProLIF and RDKit ↔ prediction.py, lines 33–100 · score 0.72 · standard deviation, Boltzmann weighted, binding free energy, MD trajectory, Delta, kcal
  11. [11] § Methods › Deep Neural Network for Binding Affinity Prediction ↔ pharmacophore_modeling.py, lines 348–451 · score 0.67 · rotatable bonds, entropy loss, SDF, Batch, embedding, centroid
  12. [12] § Results › Binding Free Energy and Dissociation Constant ↔ prediction.py, lines 33–100 · score 0.66 · Boltzmann weighted binding, standard deviation, binding free energies, kcal, predicted, frame
  13. [13] § Methods › Deep Neural Network for Binding Affinity Prediction › Ligand Quantum and Graph Representation ↔ pharmacophore_modeling.py, lines 177–221 · score 0.65 · edge_index, surface point, PMI, ESP, graph, bonds
  14. [14] § Results › Model Evaluation ↔ Binding free energy model.py, lines 343–405 · score 0.63 · MD trajectories processed, binding free energies, protein ligand, voxelized, solvation, fingerprints
  15. [15] § Results › Generative AI and PPI Framework for Glioma Target Identification ↔ language model.py, lines 18–67 · score 0.60 · flan t5 xxl, pretrained, google, database, transformer, glioma
  16. [16] § Methods › Deep Neural Network for Binding Affinity Prediction › Deep Graph Neural Network Model ↔ pharmacophore_modeling.py, lines 270–308 · score 0.60 · cross attention, multihead attention, layer, heads, ligand, protein
  17. [17] § Methods › Deep Neural Network for Binding Affinity Prediction › Protein Structure Featurization ↔ pharmacophore_modeling.py, lines 506–600 · score 0.55 · distance matrix, edge_index, graph, protein
  18. [18] § Results › Deep Interaction Featurization Using ProLIF and RDKit ↔ Binding free energy model.py, lines 343–405 · score 0.54 · binding free energies, protein ligand, slicing, voxelization, featurization, topology
  19. [19] § Results › Deep Interaction Featurization Using ProLIF and RDKit ↔ Binding free energy model.py, lines 232–264 · score 0.53 · Lennard Jones, binding free energies, ProLIF, RDKit, electrostatic, Interaction

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 · 694 lines · 27 KB · no license · 9 matches

  1. import os
  2. import sys
  3. import gc
  4. import numpy as np
  5. import pandas as pd
  6. import torch
  7. import torch.nn as nn
  8. from rdkit import Chem
  9. from rdkit.Chem import AllChem, Descriptors, rdMolDescriptors
  10. from prody import *
  11. from torch_geometric.data import Data, Batch
  12. from torch_geometric.nn import GATv2Conv, global_mean_pool
  13. from sklearn.model_selection import KFold
  14. from sklearn.metrics import r2_score
  15. from sklearn.preprocessing import StandardScaler
  16. from scipy.spatial.distance import cdist
  17. from tqdm import tqdm
  18. import warnings
  19. import datetime
  20. import psutil
  21. import traceback
  22. import pickle
  23. import json
  24. from contextlib import contextmanager
  25. from rdkit import RDLogger
  26. RDLogger.DisableLog('rdApp.*')
  28. warnings.filterwarnings("ignore")
  30. # Configuration
  31. PDB_FILE = os.path.normpath(os.path.join(os.getcwd(), "model_01_5AE1.pdb"))
  32. LIGAND_FOLDER = os.path.normpath("Ligands")
  33. ACTIVE_SITE_RESIDUES = [616,617]
  34. CHAIN_ID = "A"
  35. R = 1.987 # Gas constant in cal/(mol?K)
  37. # Checkpointing configuration
  38. CHECKPOINT_DIR = "checkpoints"
  39. DESCRIPTOR_CHECKPOINT_SIZE = 5000 # Save descriptor checkpoint every N molecules
  40. AFFINITY_CHECKPOINT_SIZE = 100 # Save affinity checkpoint every N molecules
  42. # GPU Configuration
  43. def setup_device():
  44. if torch.cuda.is_available():
  45. device = torch.device('cuda')
  46. print(f"Using GPU: {torch.cuda.get_device_name(0)}")
  47. print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
  48. # Set more conservative memory fraction
  49. torch.cuda.set_per_process_memory_fraction(0.6)
  50. else:
  51. device = torch.device('cpu')
  52. print("Using CPU - GPU not available")
  53. return device
  55. DEVICE = setup_device()
  57. # Create checkpoint directory
  58. os.makedirs(CHECKPOINT_DIR, exist_ok=True)
  60. @contextmanager
  61. def memory_cleanup():
  62. """Context manager for aggressive memory cleanup"""
  63. try:
  64. yield
  65. finally:
  66. gc.collect()
  67. if torch.cuda.is_available():
  68. torch.cuda.empty_cache()
  69. torch.cuda.synchronize()
  71. def log_memory_usage(stage=""):
  72. """Log current memory usage"""
  73. process = psutil.Process(os.getpid())
  74. cpu_mem = process.memory_info().rss / 1024 / 1024
  76. if torch.cuda.is_available():
  77. gpu_mem = torch.cuda.memory_allocated() / 1024**3
  78. gpu_cached = torch.cuda.memory_reserved() / 1024**3
  79. print(f"{stage} - CPU: {cpu_mem:.2f} MB, GPU: {gpu_mem:.2f} GB (cached: {gpu_cached:.2f} GB)")
  80. else:
  81. print(f"{stage} - CPU: {cpu_mem:.2f} MB")
  83. def save_checkpoint(data, filename):
  84. """Save checkpoint data"""
  85. try:
  86. filepath = os.path.join(CHECKPOINT_DIR, filename)
  87. if isinstance(data, pd.DataFrame):
  88. # Clean dataframe before saving
  89. data_clean = data.copy()
  90. if 'MolObj' in data_clean.columns:
  91. data_clean = data_clean.drop('MolObj', axis=1)
  92. data_clean = data_clean.replace([np.inf, -np.inf], np.nan)
  93. data_clean.to_excel(filepath, index=False)
  94. else:
  95. with open(filepath, 'wb') as f:
  96. pickle.dump(data, f)
  97. print(f"💾 Checkpoint saved: {filename}")
  98. return True
  99. except Exception as e:
  100. print(f"❌ Failed to save checkpoint {filename}: {e}")
  101. return False
  103. def load_checkpoint(filename):
  104. """Load checkpoint data"""
  105. try:
  106. filepath = os.path.join(CHECKPOINT_DIR, filename)
  107. if not os.path.exists(filepath):
  108. return None
  110. if filename.endswith('.xlsx'):
  111. return pd.read_excel(filepath)
  112. else:
  113. with open(filepath, 'rb') as f:
  114. return pickle.load(f)
  115. except Exception as e:
  116. print(f"❌ Failed to load checkpoint {filename}: {e}")
  117. return None
  119. def get_processed_files():
  120. """Get list of already processed files"""
  121. progress_file = os.path.join(CHECKPOINT_DIR, "processed_files.json")
  122. if os.path.exists(progress_file):
  123. try:
  124. with open(progress_file, 'r') as f:
  125. return json.load(f)
  126. except:
  127. return {}
  128. return {}
  130. def save_processed_files(processed_files):
  131. """Save list of processed files"""
  132. progress_file = os.path.join(CHECKPOINT_DIR, "processed_files.json")
  133. try:
  134. with open(progress_file, 'w') as f:
  135. json.dump(processed_files, f, indent=2)
  136. except Exception as e:
  137. print(f"❌ Failed to save progress: {e}")
  139. def calcAtomicFeatures(active_site):
  140. return np.zeros((active_site.numAtoms(), 10))
  142. def calcHydrophobicity(active_site):
  143. return np.zeros(active_site.numAtoms())
  145. def calcVolume(active_site):
  146. return 0.0
  148. class Electrostatics:
  149. def __init__(self, active_site):
  150. self.potentials = np.zeros(active_site.numAtoms())
  151. def getPotentials(self):
  152. return self.potentials
  154. def process_protein(pdb_file, active_site_residues):
  155. try:
  156. protein = parsePDB(pdb_file, fetch=False)
  157. sel_str = f'chain {CHAIN_ID} and resnum {" ".join(map(str, active_site_residues))}'
  158. active_site = protein.select(sel_str)
  159. if active_site is None or active_site.numAtoms() == 0:
  160. raise ValueError(f"Invalid active site selection: {sel_str}")
  161. coords = active_site.getCoords()
  162. centroid = np.mean(coords, axis=0)
  163. dummy_modes = np.zeros((active_site.numAtoms() * 3, 3))
  164. es = Electrostatics(active_site)
  165. return {
  166. 'residue_features': calcAtomicFeatures(active_site),
  167. 'anm_modes': dummy_modes,
  168. 'electrostatic': es.getPotentials(),
  169. 'hydrophobicity': calcHydrophobicity(active_site),
  170. 'volume': calcVolume(active_site),
  171. 'surface_points': coords,
  172. 'centroid': centroid
  173. }
  174. except Exception as e:
  175. raise RuntimeError(f"Failed to process protein: {e}")
  177. class LigandProcessor:
  178. def __init__(self, mol):
  179. self.mol = Chem.AddHs(mol)
  180. AllChem.EmbedMolecule(self.mol, randomSeed=42)
  181. AllChem.MMFFOptimizeMolecule(self.mol)
  183. def get_3dpharma_features(self):
  184. try:
  185. return {
  186. 'esp': 0.0,
  187. 'pmi': Descriptors.PMI1(self.mol) if hasattr(Descriptors, 'PMI1') else 0.0,
  188. 'steric': Descriptors.NPR1(self.mol) if hasattr(Descriptors, 'NPR1') else 0.0,
  189. 'affinity': 0.0
  190. }
  191. except:
  192. return {'esp': 0.0, 'pmi': 0.0, 'steric': 0.0, 'affinity': 0.0}
  194. def get_graph_representation(self):
  195. pos = torch.tensor([list(self.mol.GetConformer().GetAtomPosition(i))
  196. for i in range(self.mol.GetNumAtoms())], dtype=torch.float)
  197. features = []
  198. for atom in self.mol.GetAtoms():
  199. atom_features = [
  200. atom.GetAtomicNum(),
  201. atom.GetDegree(),
  202. atom.GetFormalCharge(),
  203. float(atom.GetHybridization().real),
  204. float(atom.GetIsAromatic())
  205. ]
  206. features.append(atom_features)
  207. x = torch.tensor(features, dtype=torch.float)
  208. bonds = list(self.mol.GetBonds())
  209. if len(bonds) > 0:
  210. edge_index = torch.tensor(
  211. [[b.GetBeginAtomIdx(), b.GetEndAtomIdx()]
  212. for b in bonds] +
  213. [[b.GetEndAtomIdx(), b.GetBeginAtomIdx()]
  214. for b in bonds], dtype=torch.long).t().contiguous()
  215. else:
  216. edge_index = torch.empty((2,0), dtype=torch.long)
  217. return Data(x=x, edge_index=edge_index, pos=pos, batch=torch.zeros(x.shape[0], dtype=torch.long))
  219. def get_surface_points(self):
  220. conf = self.mol.GetConformer()
  221. return np.array([conf.GetAtomPosition(i) for i in range(self.mol.GetNumAtoms())])
  223. def compute_descriptors(mol):
  224. try:
  225. AllChem.ComputeGasteigerCharges(mol)
  226. charges = []
  227. for atom in mol.GetAtoms():
  228. if atom.HasProp('_GasteigerCharge'):
  229. charges.append(float(atom.GetDoubleProp('_GasteigerCharge')))
  231. return {
  232. 'MolWt': Descriptors.MolWt(mol),
  233. 'MolLogP': Descriptors.MolLogP(mol),
  234. 'NumRotatableBonds': Descriptors.NumRotatableBonds(mol),
  235. 'TPSA': Descriptors.TPSA(mol),
  236. 'HBA': rdMolDescriptors.CalcNumHBA(mol),
  237. 'HBD': rdMolDescriptors.CalcNumHBD(mol),
  238. 'AromaticRings': rdMolDescriptors.CalcNumAromaticRings(mol),
  239. 'FractionCSP3': rdMolDescriptors.CalcFractionCSP3(mol),
  240. 'HeavyAtomCount': Descriptors.HeavyAtomCount(mol),
  241. 'AliphaticRings': rdMolDescriptors.CalcNumAliphaticRings(mol),
  242. 'MaxPartialCharge': max(charges) if charges else 0.0,
  243. 'MinPartialCharge': min(charges) if charges else 0.0,
  244. 'LabuteASA': rdMolDescriptors.CalcLabuteASA(mol),
  245. 'MolMR': Descriptors.MolMR(mol),
  246. 'BalabanJ': Descriptors.BalabanJ(mol),
  247. 'BertzCT': Descriptors.BertzCT(mol)
  248. }
  249. except:
  250. return {key: 0.0 for key in [
  251. 'MolWt', 'MolLogP', 'NumRotatableBonds', 'TPSA', 'HBA', 'HBD',
  252. 'AromaticRings', 'FractionCSP3', 'HeavyAtomCount', 'AliphaticRings',
  253. 'MaxPartialCharge', 'MinPartialCharge', 'LabuteASA', 'MolMR',
  254. 'BalabanJ', 'BertzCT'
  255. ]}
  257. def compute_entropy(rot_bonds):
  258. delta_s_torsion = -R * np.log(rot_bonds + 1)
  259. return delta_s_torsion
  261. def compute_distance_to_site(mol, centroid):
  262. conf = mol.GetConformer()
  263. distances = []
  264. for atom in mol.GetAtoms():
  265. pos = np.array(conf.GetAtomPosition(atom.GetIdx()))
  266. dist = np.linalg.norm(pos - centroid)
  267. distances.append(dist)
  268. return np.mean(distances), np.min(distances), np.max(distances)
  270. class PharmaGNN(nn.Module):
  271. def __init__(self, protein_feature_size=10, ligand_feature_size=5):
  272. super().__init__()
  273. self.device = DEVICE
  274. self.protein_conv1 = GATv2Conv(protein_feature_size, 128, heads=2) # Reduced complexity
  275. self.protein_conv2 = GATv2Conv(128*2, 256)
  276. self.ligand_conv1 = GATv2Conv(ligand_feature_size, 128, heads=2)
  277. self.ligand_conv2 = GATv2Conv(128*2, 256)
  278. self.cross_attention = nn.MultiheadAttention(256, 4, batch_first=True) # Reduced heads
  279. self.fc = nn.Sequential(
  280. nn.Linear(512, 256),
  281. nn.LayerNorm(256),
  282. nn.LeakyReLU(),
  283. nn.Dropout(0.2),
  284. nn.Linear(256, 1)
  285. )
  286. self.to(self.device)
  288. def forward(self, protein_data, ligand_data):
  289. # Move data to device
  290. protein_data = protein_data.to(self.device)
  291. ligand_data = ligand_data.to(self.device)
  293. # Process protein
  294. p_x = self.protein_conv1(protein_data.x, protein_data.edge_index)
  295. p_x = self.protein_conv2(p_x, protein_data.edge_index)
  296. p_x = global_mean_pool(p_x, protein_data.batch)
  298. # Process ligand
  299. l_x = self.ligand_conv1(ligand_data.x, ligand_data.edge_index)
  300. l_x = self.ligand_conv2(l_x, ligand_data.edge_index)
  301. l_x = global_mean_pool(l_x, ligand_data.batch)
  303. # Cross attention
  304. attn_out, _ = self.cross_attention(p_x.unsqueeze(1), l_x.unsqueeze(1), l_x.unsqueeze(1))
  306. # Combine features
  307. combined = torch.cat([p_x, attn_out.squeeze(1)], dim=1)
  308. return self.fc(combined)
  310. def calculate_binding_score(protein_features, ligand_features, descriptors, distances, entropy):
  311. try:
  312. sc = 1 - cdist(protein_features['surface_points'], ligand_features['surface_points'], 'cosine').mean()
  313. ec = np.corrcoef(protein_features['electrostatic'], [ligand_features['esp']])[0,1]
  314. if np.isnan(ec):
  315. ec = 0.0
  316. dist_score = 1 / (1 + distances['AvgDistToSite'])
  317. entropy_score = -entropy / R
  318. energy = (0.3 * sc) + (0.2 * ec) + (0.2 * ligand_features['affinity']) + \
  319. (0.2 * dist_score) + (0.1 * entropy_score)
  320. return energy
  321. except:
  322. return 0.0
  324. def safe_save_dataframe(df, filename, max_retries=3):
  325. """Safely save DataFrame with retries"""
  326. for attempt in range(max_retries):
  327. try:
  328. df_clean = df.copy()
  329. if 'MolObj' in df_clean.columns:
  330. df_clean = df_clean.drop('MolObj', axis=1)
  331. df_clean = df_clean.replace([np.inf, -np.inf], np.nan)
  333. with pd.ExcelWriter(filename, engine='openpyxl') as writer:
  334. df_clean.to_excel(writer, index=False, sheet_name='Results')
  336. print(f"✅ Successfully saved {filename}")
  337. return True
  339. except Exception as e:
  340. print(f"❌ Attempt {attempt + 1} failed to save {filename}: {e}")
  341. if attempt < max_retries - 1:
  342. import time
  343. time.sleep(1)
  344. else:
  345. print(f"❌ Failed to save {filename} after {max_retries} attempts")
  346. return False
  348. def process_single_sdf_file(sdf_path, sdf_file, centroid, processed_files):
  349. """Process a single SDF file with continuous checkpointing"""
  350. results = []
  351. skipped = []
  353. # Check if file already processed
  354. if sdf_file in processed_files:
  355. print(f"📁 Loading cached results for {sdf_file}...")
  356. cached_file = f"descriptors_{sdf_file.replace('.sdf', '')}.xlsx"
  357. cached_df = load_checkpoint(cached_file)
  358. if cached_df is not None:
  359. print(f"✅ Loaded {len(cached_df)} cached results for {sdf_file}")
  360. return cached_df, []
  362. print(f"🔄 Processing {sdf_file}...")
  364. try:
  365. suppl = Chem.SDMolSupplier(sdf_path, sanitize=False)
  367. batch_results = []
  368. processed_count = 0
  369. total_processed = 0
  371. for idx, mol in enumerate(suppl):
  372. if idx % 1000 == 0:
  373. print(f"\r{sdf_file}: Processing molecule {idx + 1}...", end="", flush=True)
  375. if mol is None:
  376. skipped.append((sdf_file, idx, "Unreadable molecule"))
  377. continue
  379. try:
  380. # Sanitize and prepare molecule
  381. Chem.SanitizeMol(mol)
  382. mol = Chem.AddHs(mol)
  383. res = AllChem.EmbedMolecule(mol, randomSeed=42)
  384. if res != 0:
  385. skipped.append((sdf_file, idx, "3D embedding failed"))
  386. continue
  387. AllChem.MMFFOptimizeMolecule(mol)
  389. # Compute descriptors
  390. desc = compute_descriptors(mol)
  391. avg_d, min_d, max_d = compute_distance_to_site(mol, centroid)
  392. entropy = compute_entropy(desc['NumRotatableBonds'])
  394. desc.update({
  395. 'Ligand': f"{sdf_file}_mol_{idx}",
  396. 'AvgDistToSite': avg_d,
  397. 'MinDistToSite': min_d,
  398. 'MaxDistToSite': max_d,
  399. 'EntropyLoss': entropy,
  400. 'SourceFile': sdf_file,
  401. 'MolIndex': idx
  402. })
  404. batch_results.append(desc)
  405. processed_count += 1
  406. total_processed += 1
  408. # Save checkpoint every N molecules
  409. if processed_count >= DESCRIPTOR_CHECKPOINT_SIZE:
  410. results.extend(batch_results)
  412. # Save intermediate checkpoint
  413. checkpoint_df = pd.DataFrame(results)
  414. checkpoint_file = f"descriptors_{sdf_file.replace('.sdf', '')}_temp.xlsx"
  415. save_checkpoint(checkpoint_df, checkpoint_file)
  417. batch_results = []
  418. processed_count = 0
  420. # Memory cleanup
  421. with memory_cleanup():
  422. pass
  424. except Exception as e:
  425. skipped.append((sdf_file, idx, f"Processing error: {str(e)[:100]}"))
  426. continue
  428. # Add remaining results
  429. if batch_results:
  430. results.extend(batch_results)
  432. # Save final results for this file
  433. if results:
  434. final_df = pd.DataFrame(results)
  435. final_file = f"descriptors_{sdf_file.replace('.sdf', '')}.xlsx"
  436. save_checkpoint(final_df, final_file)
  438. # Mark file as processed
  439. processed_files[sdf_file] = {
  440. 'processed_count': total_processed,
  441. 'timestamp': datetime.datetime.now().isoformat()
  442. }
  443. save_processed_files(processed_files)
  445. print(f"\r{sdf_file}: Completed - {total_processed} molecules processed")
  447. except Exception as e:
  448. print(f"\n❌ Error processing {sdf_file}: {e}")
  449. return pd.DataFrame(), skipped
  451. return pd.DataFrame(results), skipped
  453. def process_ligands_from_multiple_sdfs(folder, centroid):
  454. """Process ligands with file-level checkpointing"""
  455. all_results = []
  456. all_skipped = []
  458. sdf_files = [f for f in os.listdir(folder) if f.endswith(".sdf")]
  459. processed_files = get_processed_files()
  461. print(f"📂 Found {len(sdf_files)} SDF files")
  462. print(f"📋 {len(processed_files)} files already processed")
  464. for file_idx, sdf_file in enumerate(sdf_files):
  465. print(f"\n🔄 File {file_idx + 1}/{len(sdf_files)}: {sdf_file}")
  467. sdf_path = os.path.join(folder, sdf_file)
  469. with memory_cleanup():
  470. results_df, skipped = process_single_sdf_file(sdf_path, sdf_file, centroid, processed_files)
  472. if not results_df.empty:
  473. all_results.append(results_df)
  475. all_skipped.extend(skipped)
  477. log_memory_usage(f"After processing {sdf_file}")
  479. # Combine all results
  480. if all_results:
  481. final_df = pd.concat(all_results, ignore_index=True)
  482. print(f"\n✅ Total molecules processed: {len(final_df)}")
  483. else:
  484. final_df = pd.DataFrame()
  485. print(f"\n❌ No molecules processed successfully")
  487. if all_skipped:
  488. print(f"⚠️ Skipped {len(all_skipped)} molecules. First 10 errors:")
  489. for skip_info in all_skipped[:10]:
  490. print(f" {skip_info[0]}_mol_{skip_info[1]}: {skip_info[2]}")
  492. return final_df
  494. class PharmaPipeline:
  495. def __init__(self):
  496. print("🔬 Initializing PharmaPipeline...")
  497. log_memory_usage("Initial")
  499. self.protein_features = process_protein(PDB_FILE, ACTIVE_SITE_RESIDUES)
  500. self.model = PharmaGNN()
  501. self.model.eval()
  502. self.scaler = StandardScaler()
  504. log_memory_usage("After initialization")
  506. def process_affinity_predictions(self, ligand_df):
  507. """Process affinity predictions with continuous checkpointing"""
  508. results = []
  510. # Prepare protein data once
  511. coords = self.protein_features['surface_points']
  512. dist_matrix = cdist(coords, coords)
  513. edge_list = np.where(dist_matrix < 5.0)
  514. edge_index = torch.tensor([edge_list[0], edge_list[1]], dtype=torch.long).contiguous()
  516. protein_data = Data(
  517. x=torch.tensor(self.protein_features['residue_features'], dtype=torch.float),
  518. edge_index=edge_index,
  519. batch=torch.zeros(len(self.protein_features['residue_features']), dtype=torch.long)
  520. )
  522. print(f"🧬 Predicting affinities for {len(ligand_df)} ligands...")
  524. # Process in smaller batches
  525. batch_size = AFFINITY_CHECKPOINT_SIZE
  526. num_batches = (len(ligand_df) - 1) // batch_size + 1
  528. for batch_idx in range(num_batches):
  529. batch_start = batch_idx * batch_size
  530. batch_end = min(batch_start + batch_size, len(ligand_df))
  532. print(f"\n🔄 Affinity batch {batch_idx + 1}/{num_batches} ({batch_start + 1}-{batch_end})")
  534. batch_results = []
  536. with memory_cleanup():
  537. for idx in range(batch_start, batch_end):
  538. row = ligand_df.iloc[idx]
  540. if (idx - batch_start) % 20 == 0:
  541. progress = f"Progress: {idx - batch_start + 1}/{batch_end - batch_start}"
  542. print(f"\r{progress}", end="", flush=True)
  544. try:
  545. # Create molecule from SMILES or use stored mol object
  546. mol_data = row.to_dict()
  548. # Create a dummy molecule for testing (replace with actual mol reconstruction)
  549. mol = Chem.MolFromSmiles('CCO') # Placeholder
  550. if mol is None:
  551. continue
  553. with torch.no_grad():
  554. lp = LigandProcessor(mol)
  555. pharma_features = lp.get_3dpharma_features()
  556. graph = lp.get_graph_representation()
  558. # Predict affinity
  559. affinity = self.model(protein_data, graph)
  560. pharma_features['affinity'] = affinity.item()
  562. # Calculate physical score
  563. phys_score = calculate_binding_score(
  564. self.protein_features,
  565. {'surface_points': lp.get_surface_points(), **pharma_features},
  566. mol_data,
  567. {'AvgDistToSite': row['AvgDistToSite']},
  568. row['EntropyLoss']
  569. )
  571. final_score = 0.7 * affinity.item() + 0.3 * phys_score
  573. result = {
  574. 'Drug': row['Ligand'],
  575. 'Affinity': affinity.item(),
  576. 'PhysScore': phys_score,
  577. 'FinalScore': final_score,
  578. **pharma_features,
  579. **mol_data
  580. }
  582. batch_results.append(result)
  584. except Exception as e:
  585. print(f"\n❌ Error predicting for {row['Ligand']}: {e}")
  586. continue
  588. # Save batch results
  589. results.extend(batch_results)
  591. if results:
  592. checkpoint_df = pd.DataFrame(results)
  593. timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
  594. checkpoint_file = f"affinity_results_batch_{batch_idx + 1}_{timestamp}.xlsx"
  595. save_checkpoint(checkpoint_df, checkpoint_file)
  596. print(f"\n💾 Saved {len(results)} affinity predictions")
  598. log_memory_usage(f"After affinity batch {batch_idx + 1}")
  600. return pd.DataFrame(results)
  602. def run(self):
  603. """Main pipeline execution with comprehensive checkpointing"""
  604. try:
  605. print("🚀 Starting PharmaPipeline execution...")
  607. # Validate inputs
  608. pdb_path = os.path.normpath(PDB_FILE)
  609. ligand_folder = os.path.normpath(LIGAND_FOLDER)
  611. if not os.path.exists(pdb_path):
  612. raise FileNotFoundError(f"PDB file {pdb_path} not found")
  613. if not os.path.exists(ligand_folder):
  614. raise FileNotFoundError(f"Ligand folder {ligand_folder} not found")
  616. # Step 1: Process ligand descriptors
  617. print("\n📊 Step 1: Processing ligand descriptors...")
  618. ligand_df = process_ligands_from_multiple_sdfs(ligand_folder, self.protein_features['centroid'])
  620. if ligand_df.empty:
  621. print("❌ No ligands processed successfully")
  622. return None
  624. # Step 2: Process affinity predictions
  625. print("\n🧬 Step 2: Processing affinity predictions...")
  626. results_df = self.process_affinity_predictions(ligand_df)
  628. if results_df.empty:
  629. print("❌ No affinity predictions completed")
  630. return None
  632. # Step 3: Final processing and saving
  633. print("\n📈 Step 3: Final processing...")
  634. results_df = results_df.sort_values('FinalScore', ascending=False)
  636. # Save final results
  637. timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
  638. output_file = f"Nature_Methods_Pharma_Ranking_{timestamp}.xlsx"
  640. success = safe_save_dataframe(results_df, output_file)
  642. if success:
  643. print(f"\n📄 Final output saved to: {output_file}")
  644. print(f"🏆 Top 5 compounds by FinalScore:")
  645. display_cols = ['Drug', 'FinalScore', 'Affinity', 'PhysScore']
  646. available_cols = [col for col in display_cols if col in results_df.columns]
  647. print(results_df[available_cols].head().to_string())
  649. return results_df
  651. except Exception as e:
  652. print(f"❌ Pipeline failed: {e}")
  653. print("🔍 Full traceback:")
  654. traceback.print_exc()
  655. return None
  657. finally:
  658. print("\n🧹 Performing final cleanup...")
  659. with memory_cleanup():
  660. pass
  661. log_memory_usage("Final cleanup")
  663. if __name__ == "__main__":
  664. try:
  665. log_memory_usage("Program start")
  667. print("🔬 Nature Methods Pharma Analysis Pipeline")
  668. print("=" * 50)
  670. pipeline = PharmaPipeline()
  671. result_df = pipeline.run()
  673. if result_df is not None:
  674. print("\n🎉 Nature Methods-ready analysis complete!")
  675. print(f"✅ Successfully processed {len(result_df)} compounds")
  676. else:
  677. print("\n❌ Analysis failed - check error messages above")
  679. log_memory_usage("Program end")
  681. except KeyboardInterrupt:
  682. print("\n⚠️ Process interrupted by user")
  683. print("💾 Checkpoint files have been saved - you can resume processing")
  684. sys.exit(1)
  685. except Exception as e:
  686. print(f"\n💥 Unexpected error: {e}")
  687. print("🔍 Full traceback:")
  688. traceback.print_exc()
  689. sys.exit(1)
  690. finally:
  691. print("\n🧹 Final cleanup...")
  692. with memory_cleanup():
  693. pass
  694. print("🏁 Program finished.")

pharmacophore_modeling.py at commit 9e48132, no license · at the source

Overview

Authors: Amritha Thaikkad1, Sonet Daniel Thomas1,2, Leona Dcunha1, Levin John1, Jishna Vijayan1, Naveen Joy1, Radul R Dev1, Rajesh Raju1, Abhithaj Jayanandan1
ORCID iDs: Amritha Thaikkad, Naveen Joy, Rajesh Raju, Abhithaj Jayanandan
  1. Centre for Integrative Omics Data Science (CIODS), Yenepoya (Deemed to be University), Mangalore 575018, Karnataka, India
  2. Center for Systems Biology and Molecular Medicine (CSBMM), Yenepoya (Deemed to be University), Mangalore 575018, Karnataka, India
Institutions: Yenepoya University (India)
Journal: ACS omega, volume 11, issue 11, pages 17249-17265
Dates: received 9 September 2025; accepted 29 January 2026; published online 11 March 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1021/acsomega.5c09368 · PMID 41908407 · PMCID PMC13019191 · OpenAlex W7134966412
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: other condition (population)
Methods: Smoothing, state filtering, decompositions, Machine learning, Connectivity
Topic: Biological Research and Disease Studies (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Citations: cited by 1 paper (Europe PMC); 46 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

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

naveen-joy-18/Feature-driven-AI-Guided-Drug-Repurposing-Pipeline-for-AGPS-Targeted-Glioma-Therapy-

License: none: the authors keep all their rights
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: 9e481328d5f3663cf67336f5a1a036a791a8def3, 18 December 2025
Languages: Python (5)
Size: 8 files, 5 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (5 files), PyTorch (5 files), pandas (4 files), Matplotlib (2 files), RDKit (2 files), seaborn (2 files), Hugging Face Transformers (2 files), Biopython (1 file), Plotly (1 file), PyTorch Geometric (1 file), scikit-learn (1 file), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
6 files
At the source: github.com/naveen-joy-18/Feature-driven-AI-Guided-Drug-Repurposing-Pipeline-for-AGPS-Targeted-Glioma-Therapy-.git

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;
  • 5 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

Datasets cited

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1021/acsomega.5c09368.

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 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 9 authors, 44 references.

Cite

This paper

Thaikkad, A., Thomas, S. D., Dcunha, L., John, L., Vijayan, J., Joy, N., R Dev, R., Raju, R., & Jayanandan, A. (2026). Structure-Based and AI-Assisted Identification of AGPS Inhibitors for Glioma via Integrated Docking, Molecular Dynamics, and Binding Affinity Screening. ACS omega, 11(11), 17249-17265. https://doi.org/10.1021/acsomega.5c09368

BibTeX

@article{thaikkad2026structure,
author = {Thaikkad, Amritha and Thomas, Sonet Daniel and Dcunha, Leona and John, Levin and Vijayan, Jishna and Joy, Naveen and R Dev, Radul and Raju, Rajesh and Jayanandan, Abhithaj},
title = {{Structure-Based and AI-Assisted Identification of AGPS Inhibitors for Glioma via Integrated Docking, Molecular Dynamics, and Binding Affinity Screening}},
journal = {ACS omega},
year = {2026},
month = mar,
volume = {11},
number = {11},
pages = {17249--17265},
publisher = {American Chemical Society},
issn = {2470-1343},
doi = {10.1021/acsomega.5c09368},
url = {https://doi.org/10.1021/acsomega.5c09368},
pmid = {41908407},
pmcid = {PMC13019191}
}

RIS

TY - JOUR
AU - Thaikkad, Amritha
AU - Thomas, Sonet Daniel
AU - Dcunha, Leona
AU - John, Levin
AU - Vijayan, Jishna
AU - Joy, Naveen
AU - R Dev, Radul
AU - Raju, Rajesh
AU - Jayanandan, Abhithaj
TI - Structure-Based and AI-Assisted Identification of AGPS Inhibitors for Glioma via Integrated Docking, Molecular Dynamics, and Binding Affinity Screening
T2 - ACS omega
J2 - ACS Omega
PY - 2026
DA - 2026/03/11
VL - 11
IS - 11
SP - 17249
EP - 17265
SN - 2470-1343
PB - American Chemical Society
DO - 10.1021/acsomega.5c09368
UR - https://doi.org/10.1021/acsomega.5c09368
LA - en
ER -

CSL-JSON

{
"id": "10.1021/acsomega.5c09368",
"type": "article-journal",
"title": "Structure-Based and AI-Assisted Identification of AGPS Inhibitors for Glioma via Integrated Docking, Molecular Dynamics, and Binding Affinity Screening",
"container-title": "ACS omega",
"author": [
{
"family": "Thaikkad",
"given": "Amritha"
},
{
"family": "Thomas",
"given": "Sonet Daniel"
},
{
"family": "Dcunha",
"given": "Leona"
},
{
"family": "John",
"given": "Levin"
},
{
"family": "Vijayan",
"given": "Jishna"
},
{
"family": "Joy",
"given": "Naveen"
},
{
"family": "R Dev",
"given": "Radul"
},
{
"family": "Raju",
"given": "Rajesh"
},
{
"family": "Jayanandan",
"given": "Abhithaj"
}
],
"container-title-short": "ACS Omega",
"volume": "11",
"issue": "11",
"page": "17249-17265",
"DOI": "10.1021/acsomega.5c09368",
"PMID": "41908407",
"PMCID": "PMC13019191",
"ISSN": "2470-1343",
"publisher": "American Chemical Society",
"URL": "https://doi.org/10.1021/acsomega.5c09368",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
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.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: RDKit, Biopython, Hugging Face Transformers, 8 other tools
[2] 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, Biopython, PyTorch Geometric, 6 other tools, other condition
[3] 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, Plotly, 7 other tools
[4] doi:10.1002/hbm.70469 [code]
VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI.
Journal: Human brain mapping
In common: PyTorch Geometric, Hugging Face Transformers, Plotly, 7 other tools
[5] 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, Biopython, PyTorch Geometric, 6 other tools
[6] doi:10.1038/s41586-026-10391-0 [code]
Cell-type-targeted mitochondrial transplantation rescues cell degeneration.
Journal: Nature
In common: RDKit, Biopython, PyTorch Geometric, 6 other tools
[7] doi:10.1021/acs.biochem.5c00596 [code]
Cargo Recognition of Nesprin-2 by the Dynein Adapter Bicaudal D2 for a Nuclear Positioning Pathway That Is Important for Brain Development.
Journal: Biochemistry
In common: RDKit, Biopython, PyTorch Geometric, 6 other tools
[8] 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, PyTorch Geometric, PyTorch, 6 other tools, other condition
[9] 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, Hugging Face Transformers, 5 other tools
[10] doi:10.1093/nar/gkag706 [code]
scDifformer: diffusion-based post-training for virtual cell modeling across large-scale single-cell data.
Journal: Nucleic acids research
In common: RDKit, PyTorch Geometric, PyTorch, 6 other tools

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.