OSCR

DeorphaNN: Virtual screening of GPCR peptide agonists using AlphaFold-predicted active-state complexes and deep learning embeddings.

Code ↔ Paper

15 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 15 matches
  1. [1] § Star★Methods › Method Details › Model architecture and training ↔ DeorphaNN_training.ipynb, lines 568–692 · score 0.81 · AdamW, CrossEntropyLoss, DataLoader, smoothing, optimizer, PyTorch
  2. [2] § Star★Methods › Method Details › Model architecture and training ↔ DeorphaNN_training.ipynb, lines 568–692 · score 0.74 · precision score, Optuna, GPCR families, subsampled, shuffle, seed
  3. [3] § Results › AF-multimer confidence metrics partially discriminate peptide agonists from non-agonists ↔ src/analysis/vis_analyze.py, lines 194–288 · score 0.70 · interface contacts, pDockQ, plDDT, metrics, AF, chains
  4. [4] § Star★Methods › Method Details › AlphaFold2 ↔ structure_prediction/colabfold_runner.py, lines 226–287 · score 0.69 · max_msa, multimer v3, auto, v1, ColabFold, AlphaFold2
  5. [5] § Star★Methods › Method Details › AlphaFold2 ↔ preprocessing/minimum_distance.ipynb, lines 35–157 · score 0.68 · minimum distance, DeepTMHMM, binding pocket, atoms, error, positions
  6. [6] § Star★Methods › Method Details › AlphaFold2 ↔ src/alphafold/notebooks/AlphaFold.ipynb, lines 334–397 · score 0.67 · predicted aligned error, residue pLDDT, confidence metric, PAE, atoms, model
  7. [7] § Star★Methods › Method Details › AlphaFold2 ↔ alphafold/common/mmcif_metadata.py, lines 72–213 · score 0.58 · top ranked, pLDDT, coevolutionary, protocol, databases, conformations
  8. [8] § Star★Methods › Method Details › Model architecture and training ↔ esm/inverse_folding/gvp_modules.py, lines 331–475 · score 0.57 · node embeddings, convolutional, PyTorch, aggregates, ReLU, Geometric
  9. [9] § Results › AF-multimer confidence metrics partially discriminate peptide agonists from non-agonists ↔ structure_prediction/alphafold/common/confidence.py, lines 111–168 · score 0.56 · ipTM, predicted aligned error, confidence, interface, alignment, chains
  10. [10] § Star★Methods › Method Details › Phylogenetic analysis of GPCRs ↔ alphafold/data/tools/hmmbuild.py, lines 27–144 · score 0.54 · scoring matrix, aligned sequences, substitution, amino, model
  11. [11] § Star★Methods › Method Details › Phylogenetic analysis of GPCRs ↔ structure_prediction/alphafold/data/tools/hmmbuild.py, lines 26–138 · score 0.54 · scoring matrix, aligned sequences, substitution, amino, model
  12. [12] § Star★Methods › Method Details › Arpeggio ↔ structure_prediction/alphafold/model/all_atom.py, lines 744–850 · score 0.53 · van der Waals, bonds, atom, distance, position, residue
  13. [13] § Star★Methods › Method Details › Arpeggio ↔ alphafold/model/all_atom.py, lines 847–971 · score 0.52 · van der Waals, bonds, atom, distance, position, residue
  14. [14] § Star★Methods › Method Details › Model architecture and training ↔ esm/inverse_folding/gvp_modules.py, lines 331–475 · score 0.52 · attention heads, PyTorch, aggregating, Network, Geometric, dropout
  15. [15] § Results › AF-multimer confidence metrics partially discriminate peptide agonists from non-agonists ↔ src/analysis/vis_analyze.py, lines 292–375 · score 0.52 · pDockQ, top scoring, curves, ROC, plDDT, metric

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

Jupyter notebook · 700 lines · 25 KB · MIT · 2 matches

  1. # %% [markdown]
  2. # <a href="https://colab.research.google.com/github/Zebreu/DeorphaNN/blob/main/DeorphaNN_training.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>
  4. # %%
  5. #location to save results
  6. save_to = '/content/'
  8. # %%
  9. #@title Install Dependencies
  10. %%capture
  11. !pip uninstall torch -y
  12. !pip install torch==2.4.0
  13. !pip install pyg_lib torch_scatter torch_sparse torch_cluster torch_spline_conv -f https://data.pyg.org/whl/torch-2.4.0+cu121.html
  14. !pip install torch-geometric
  15. !pip install optuna
  16. !pip install numpy-indexed
  18. import glob
  19. import warnings
  20. import numpy as np
  21. import numpy_indexed as npi
  22. import pandas as pd
  23. import scipy
  24. from collections import defaultdict
  26. from sklearn.metrics import roc_auc_score, confusion_matrix, average_precision_score
  28. import torch
  29. from torch.nn import Linear
  30. import torch.nn.functional as F
  32. import torch_geometric
  33. from torch_geometric.data import Data
  34. from torch_geometric.loader import DataLoader
  35. from torch_geometric.nn import GCNConv, GATv2Conv
  36. from torch_geometric.nn import global_mean_pool, global_add_pool, global_max_pool
  37. from torch_geometric.nn import aggr
  38. from torch_geometric.nn.norm import GraphNorm
  40. from sklearn import preprocessing
  42. import optuna
  44. torch.manual_seed(111)
  45. from huggingface_hub import hf_hub_download, list_repo_files
  46. import h5py
  47. import random
  50. # %%
  51. #@title Import files from HuggingFace repo
  52. %%capture
  53. repo_id = "lariferg/DeorphaNN"
  54. all_files = list_repo_files(repo_id, repo_type="dataset")
  56. pdbs_paths = sorted(
  57. hf_hub_download(repo_id, f, repo_type="dataset")
  58. for f in all_files
  59. if f.startswith("DeorphaNN_training/nov7relaxed") and f.endswith(".parquet")
  60. )
  62. labels = hf_hub_download(
  63. repo_id,
  64. next(f for f in all_files if f.startswith("DeorphaNN_training/") and f.endswith("Dataset_Labels_full - Sheet1.csv")),
  65. repo_type="dataset"
  66. )
  67. beetsdata = pd.read_csv(labels)
  70. min_dis = hf_hub_download(
  71. repo_id,
  72. next(f for f in all_files if f.startswith("DeorphaNN_training/") and f.endswith("mindistance_active_bias.csv")),
  73. repo_type="dataset"
  74. )
  75. outsidepocket = pd.read_csv(min_dis)
  78. new_contacts_paths = sorted(
  79. hf_hub_download(repo_id, f, repo_type="dataset")
  80. for f in all_files
  81. if f.startswith("DeorphaNN_training/nov7relaxed") and f.endswith("_arpeggio_contacts3.parquet")
  82. )
  84. hdfs_int = sorted(
  85. hf_hub_download(repo_id, f, repo_type="dataset")
  86. for f in all_files
  87. if f.startswith("pair_representations/") and f.endswith("_interaction.h5")
  88. )
  91. hdfs_t = sorted(
  92. hf_hub_download(repo_id, f, repo_type="dataset")
  93. for f in all_files
  94. if f.startswith("pair_representations/") and f.endswith("T.h5")
  95. )
  98. # %% [markdown]
  99. # ###Preparing data
  101. # %%
  102. gpcrs = []
  103. peptides = []
  104. plddts = []
  105. paths = []
  106. plddt_peptides = []
  107. plddt_gpcrs = []
  108. plddt_atoms = []
  109. pdb_frames = dict()
  110. for pdbs in pdbs_paths:
  111. print(pdbs)
  112. pdbs = pd.read_parquet(pdbs)
  113. for key, st in pdbs.groupby('path'):
  114. if 'amber_r_' in key:
  115. original_key = key
  116. key = key.replace('amber_r_', '')
  117. gpcrs.append(key.split('/')[-1].split('_')[0])
  118. peptides.append(key.split('/')[-1].split('_')[1])
  119. plddt_peptides.append(st[st['chain_id'] == 'B'].groupby('residue_seq_id')['b_factor'].first().mean())
  120. plddt_gpcrs.append(st[st['chain_id'] == 'A'].groupby('residue_seq_id')['b_factor'].first().mean())
  121. plddt_atoms.append(st[st['chain_id'] == 'B']['b_factor'].mean())
  122. paths.append(original_key)
  123. pdb_frames[original_key] = st
  124. del pdbs
  126. # %%
  127. st = pd.DataFrame({'path': paths, 'gpcr': gpcrs, 'peptide': peptides, 'plddt_peptides': plddt_peptides, 'plddt_gpcrs': plddt_gpcrs, 'plddt_atoms': plddt_atoms})
  128. merged = pd.merge(beetsdata, st, how='left', left_on=['GPCR name', 'Peptide'], right_on=['gpcr', 'peptide'])
  129. merged['gpcr_family'] = merged['GPCR name'].str[:-2]
  130. merged['y'] = merged['binds'].apply(lambda x: 1 if x == True else 0)
  132. # %%
  133. gpcr_hits = merged[merged['gpcr'].isna() == False]
  134. gpcrs_lens = []
  135. peps_lens = []
  136. for index, st in gpcr_hits.iterrows():
  137. pdb = pdb_frames[st['path']]
  138. rec = pdb[pdb['chain_id'] == 'A']
  139. pep = pdb[pdb['chain_id'] == 'B']
  140. gpcrs_lens.append(rec['residue_seq_id'].max())
  141. peps_lens.append(pep['residue_seq_id'].max())
  142. gpcr_hits['gpcr_len'] = gpcrs_lens
  143. gpcr_hits['pep_len'] = peps_lens
  145. # %%
  146. outsidepocket['pair'] = outsidepocket['GPCR name']+'_'+outsidepocket['Peptide']
  148. # %%
  149. gpcr_hits = gpcr_hits[-gpcr_hits['pair'].isin(set(outsidepocket['pair'].values))]
  151. # %%
  152. allcontacts_new = []
  153. for cpath_new in new_contacts_paths:
  154. allcontacts_new.append(pd.read_parquet(cpath_new))
  155. allcontacts_new = pd.concat(allcontacts_new)
  157. # %%
  158. len(allcontacts_new)
  160. # %%
  161. allcontacts_new
  163. # %%
  164. total_interactions = allcontacts_new.groupby('gpcr_peptide')['contacts'].apply(lambda x: sum(len(c) for c in x)).reset_index()
  165. total_interactions.columns = ['gpcr_peptide', 'total_interactions']
  168. # %%
  169. total_interactions
  171. # %%
  172. gpcr_hits
  174. # %%
  175. gpcr_hits_bonds = pd.merge(
  176. gpcr_hits,
  177. total_interactions,
  178. how='left',
  179. left_on='pair',
  180. right_on='gpcr_peptide'
  181. )
  183. # Optionally drop the redundant 'gpcr_peptide' column
  184. gpcr_hits_bonds = gpcr_hits_bonds.drop(columns=['gpcr_peptide'])
  187. # %%
  188. gpcr_hits_bonds
  190. # %%
  191. interactions = dict()
  192. for key, st in allcontacts_new.groupby('gpcr_peptide'):
  193. interactions[key] = st
  195. # %%
  196. gpcr_hits_interaction_edges = dict()
  197. for index, g in gpcr_hits.iterrows():
  198. pdb = pdb_frames[g['path']].copy()
  199. if g['path'] not in interactions:
  200. continue
  201. bonds = interactions[g['path']]
  203. gpcr_len = g['gpcr_len']
  205. # they're 1-indexed so -1
  206. bonds['source'] = bonds['bgn'].apply(lambda x: x['auth_seq_id'] if x['auth_asym_id'] == "A" else x['auth_seq_id'] + gpcr_len) - 1
  207. bonds['target'] = bonds['end'].apply(lambda x: x['auth_seq_id'] if x['auth_asym_id'] == "A" else x['auth_seq_id'] + gpcr_len) - 1
  208. bonds = bonds.groupby(['source', 'target'])['contact'].agg(lambda x: {bondtype for array in x for bondtype in array}).reset_index()
  209. sources = bonds['source'].values
  210. targets = bonds['target'].values
  212. h_edge_index = np.vstack([sources,targets])
  213. key = g['gpcr']+'_'+g['peptide']
  214. gpcr_hits_interaction_edges[key] = h_edge_index
  216. # %%
  217. gpcr_hits_interaction_edges_new = dict()
  218. for _, row in allcontacts_new.iterrows():
  219. key = row['gpcr_peptide']
  220. contacts = row['contacts']
  221. # Check if contacts is None, NaN, or empty
  222. if contacts is None or len(contacts) == 0:
  223. # create empty 2x0 array
  224. #gpcr_hits_interaction_edges_new[key] = np.empty((2,0), dtype=int)
  225. continue
  226. # Stack the pairs vertically and transpose
  227. arr = np.vstack(contacts).T # shape: 2 x N_pairs
  228. arr -= 1 #convert 1-indexed to 0-indexed
  229. gpcr_hits_interaction_edges_new[key] = arr
  231. # %%
  232. len(gpcr_hits_interaction_edges_new)
  234. # %%
  235. len(interactions)
  237. # %%
  238. gpcr_hits_interaction_edges_new['DMSR-5-1_FLP-1-7']
  240. # %%
  241. lens = gpcr_hits.groupby(['GPCR name'])['gpcr_len'].first()
  243. # %%
  244. len(hdfs_int)
  246. # %%
  247. emb_map_interaction = dict()
  248. emb_map_interaction_gpcrindex = dict()
  249. pairmissed = []
  250. for hdf in hdfs_int:
  251. with h5py.File(hdf, "r") as f:
  252. keys = list(f.keys())
  253. print(keys)
  254. gpcr = keys[0].split('_')[0]
  255. for k in keys:
  256. try:
  257. array = np.nan_to_num(f[k][()],0)
  258. peptide = k.split('_')[1]
  259. mapkey = gpcr+'_'+peptide
  260. indices_to_keep = set()
  261. maximum = lens[gpcr]
  262. indices_to_keep.update(set(gpcr_hits_interaction_edges_new[mapkey][0]))
  263. indices_to_keep.update(set(gpcr_hits_interaction_edges_new[mapkey][1]))
  264. indices_to_keep = sorted([i for i in indices_to_keep if i < maximum])
  265. emb_map_interaction[mapkey] = array[:,indices_to_keep,:]
  266. emb_map_interaction_gpcrindex[mapkey] = np.array(indices_to_keep)
  267. print("success "+k)
  268. except:
  269. pairmissed.append(k)
  270. print("missed "+k)
  271. continue
  273. # %%
  274. len(emb_map_interaction)
  276. # %%
  277. len(pairmissed)
  279. # %%
  280. all_peptide_arrays = []
  281. peptide_keys = []
  282. all_gpcr_arrays = []
  283. gpcr_keys = []
  285. for hdf in hdfs_t:
  286. with h5py.File(hdf, "r") as f:
  287. arrays = []
  288. keys = list(f.keys())
  290. for k in keys:
  291. arrays.append(f[k][()])
  292. if "_pep_T" in hdf:
  293. all_peptide_arrays.append(arrays)
  294. peptide_keys.append(keys)
  295. if "_gpcr_T" in hdf:
  296. all_gpcr_arrays.append(arrays)
  297. gpcr_keys.append(keys)
  299. # %%
  300. emb_map_gpcr = dict()
  301. for keys, arrays in zip(gpcr_keys, all_gpcr_arrays):
  302. try:
  303. gpcr = keys[0].split('_')[0]
  305. for i,array in enumerate(arrays):
  306. peptide = keys[i].split('_')[1]
  307. emb_map_gpcr[gpcr+'_'+peptide] = array
  308. except:
  309. print('oops')
  310. continue
  312. # %%
  313. emb_map_peptide = dict()
  314. for keys, arrays in zip(peptide_keys, all_peptide_arrays):
  315. try:
  316. gpcr = keys[0].split('_')[0]
  318. for i,array in enumerate(arrays):
  319. peptide = keys[i].split('_')[1]
  320. emb_map_peptide[gpcr+'_'+peptide] = array
  322. except:
  323. print('oops')
  324. continue
  326. # %%
  327. embst = pd.DataFrame({'gpcr_keys': [kk for k in gpcr_keys for kk in k ], 'gpcr_embedding': [aa.mean(axis=0) for a in all_gpcr_arrays for aa in a ], 'peptide_keys': [kk for k in peptide_keys for kk in k], 'peptide_embedding': [aa.mean(axis=0) for a in all_peptide_arrays for aa in a]})
  329. # %%
  330. embst['peptide'] = embst['peptide_keys'].apply(lambda x: x.split('_')[1])
  331. embst['gpcr'] = embst['gpcr_keys'].apply(lambda x: x.split('_')[0])
  333. # %%
  334. gpcrweight = 1/gpcr_hits.groupby(['gpcr']).agg({'y': 'sum'}).sort_values(by='y')
  336. # %%
  337. gpcrweight
  339. # %%
  340. gpcr_hits
  342. # %%
  343. subgraphing = True
  344. subgraph_hops = 1
  345. with_edge_weights = True
  346. missed = []
  347. all_graphs = []
  348. for index, g in gpcr_hits.iterrows():
  349. mapkey = g['gpcr']+'_'+g['peptide']
  350. if mapkey not in gpcr_hits_interaction_edges_new:
  351. missed.append((mapkey, g['y']))
  352. continue
  353. gpcr_len = g['gpcr_len']
  354. h_edge_index = gpcr_hits_interaction_edges_new[g['gpcr']+'_'+g['peptide']]
  355. xg = emb_map_gpcr[g['gpcr']+'_'+g['peptide']]
  356. xp = emb_map_peptide[g['gpcr']+'_'+g['peptide']]
  357. x = np.concatenate([xg, xp])
  358. x = torch.from_numpy(x).type(torch.float32)
  359. pep_edge_index = np.vstack([np.array(range(g['gpcr_len'], len(x)-1)), np.array(range(g['gpcr_len']+1, len(x)))])
  360. edge_index = torch.cat([torch.from_numpy(h_edge_index), torch.from_numpy(pep_edge_index)], dim=1)
  361. if with_edge_weights:
  362. if mapkey not in emb_map_interaction:
  363. missed.append((mapkey, g['y']))
  364. continue
  365. edgefeatures = emb_map_interaction[mapkey]
  366. edgeindices = emb_map_interaction_gpcrindex[mapkey]
  367. sources = npi.remap(h_edge_index[0], edgeindices, np.arange(len(edgeindices)))
  368. targets = npi.remap(h_edge_index[1], edgeindices, np.arange(len(edgeindices)))
  369. sourcewherever = np.where(sources >= gpcr_len)[0]
  370. targetwherever = np.where(targets < gpcr_len)[0]
  371. newsources = np.array(sources)
  372. newtargets = np.array(targets)
  373. newsources[sourcewherever] = targets[sourcewherever]
  374. newtargets[targetwherever] = sources[targetwherever]
  375. newtargets -= gpcr_len
  376. edge_attrs = edgefeatures[newtargets, newsources, :]
  377. pep_edge_attrs = np.ones(shape=(len(pep_edge_index[0]),128))*edge_attrs.mean(axis=0)
  378. edge_attrs = torch.from_numpy(edge_attrs).type(torch.float32)
  379. edge_attrs = torch.cat([edge_attrs, torch.from_numpy(pep_edge_attrs)], dim=0)
  380. if with_edge_weights:
  381. # convert to undirected first, so hops are symmetric
  382. edge_index, edge_attrs = torch_geometric.utils.to_undirected(edge_index, edge_attrs, reduce='mean')
  383. if subgraphing:
  384. to_keep = torch.tensor([i for i in range(gpcr_len, len(x))]) #hopping from peptide nodes
  385. # to_keep = torch.unique(torch.from_numpy(h_edge_index[0])) #hopping from gpcr nodes
  387. nodes, edges, _, _ = torch_geometric.utils.k_hop_subgraph(to_keep, subgraph_hops, edge_index, relabel_nodes=True, num_nodes=len(x))
  388. # mask = (nodes >= gpcr_len) | (torch.isin(nodes, to_keep))
  389. # nodes = nodes[mask]
  390. if with_edge_weights:
  391. edges, new_edge_attrs = torch_geometric.utils.subgraph(nodes, edge_index, edge_attrs, relabel_nodes=True)
  392. # edges, new_edge_attrs = torch_geometric.utils.to_undirected(edges, new_edge_attrs, reduce='mean')
  393. graph = Data(x=x[nodes], edge_index=edges, edge_attr=new_edge_attrs, y=torch.tensor(g['y']))
  394. else:
  395. graph = Data(x=x[nodes], edge_index=edges, y=torch.tensor(g['y']))
  396. else:
  397. graph = Data(x=x, edge_index=edge_index, y=torch.tensor(g['y']))
  398. graph.peptide = g['peptide']
  399. graph.gpcr = g['gpcr']
  400. graph.gpcr_family = g['gpcr_family']
  401. #graph.zscore = g['modifiedzscore']
  402. gpcrw = gpcrweight.loc[g['gpcr']].iloc[0]
  403. all_graphs.append({'graph': graph, 'peptide':g['peptide'], 'gpcr':g['gpcr'], 'gpcr_family': g['gpcr_family'], 'y': g['y'], 'gpcrweight': gpcrw})
  406. # %%
  407. len(all_graphs)
  409. # %%
  410. len(missed)
  412. # %%
  413. print(missed)
  415. # %% [markdown]
  416. # #Train
  418. # %%
  419. from torch_geometric.loader import DataLoader
  420. from sklearn.metrics import roc_auc_score
  422. def train(model, criterion, optimizer, train_loader):
  423. model.train()
  424. total_loss = 0
  425. for data in train_loader:
  426. optimizer.zero_grad()
  427. logits = model(data.x, data.edge_index, data.edge_attr, data.batch) # edge_attr
  428. loss = criterion(logits, data.y)
  429. loss.backward()
  430. optimizer.step()
  431. total_loss += float(loss) * data.num_graphs
  433. return total_loss / len(train_loader.dataset)
  435. def train_weighted(model, criterion, optimizer, train_loader):
  436. model.train()
  437. total_loss = 0
  438. for data in train_loader:
  439. optimizer.zero_grad()
  440. logits = model(data.x, data.edge_index, data.edge_attr, data.batch) # edge_attr
  441. loss = criterion(logits, data.y)
  442. loss = (loss*data.gpcrweight).mean()
  443. loss.backward()
  444. optimizer.step()
  445. total_loss += float(loss) * data.num_graphs
  447. return total_loss / len(train_loader.dataset)
  449. @torch.no_grad()
  450. def test_roc(model, criterion, loader):
  451. model.eval()
  452. aucs = 0
  453. total = len(loader.dataset)
  454. correct = 0
  455. for data in loader: # Iterate in batches over the training/test dataset.
  456. out = model(data.x, data.edge_index, data.edge_attr, data.batch) # edge_attr
  457. aucs += roc_auc_score(data.y.detach().cpu(), torch.softmax(out.detach(),dim=1).cpu()[:, 1])*(len(out)/total)
  458. return aucs
  460. @torch.no_grad()
  461. def test_without_crash(model, criterion, loader):
  462. model.eval()
  463. all_logits = []
  464. atrues = []
  465. for data in loader:
  466. logits = model(data.x, data.edge_index, data.edge_attr, data.batch) # data.edge_attr
  467. all_logits.append(logits.cpu().detach()[:,1])
  468. atrues.append(data.y.cpu())
  469. return roc_auc_score(np.concatenate(atrues), np.concatenate(all_logits))
  471. @torch.no_grad()
  472. def nope_test_without_crash(model, criterion, loader):
  473. model.eval()
  474. all_logits = []
  475. atrues = []
  476. for data in loader:
  477. logits = model(data.x, data.edge_index, data.edge_attr, data.batch) # data.edge_attr
  478. all_logits.append(torch.sigmoid(logits.squeeze()).cpu().detach())
  479. atrues.append(data.y.cpu())
  480. return roc_auc_score(np.concatenate(atrues), np.concatenate(all_logits))
  482. @torch.no_grad()
  483. def test(model, criterion, loader):
  484. model.eval()
  486. total_correct = 0
  487. for data in loader:
  488. logits = model(data.x, data.edge_index, data.edge_attr, data.batch) # data.edge_attr
  489. pred = logits.argmax(dim=-1)
  490. total_correct += int((pred == data.y).sum())
  492. return total_correct / len(test_loader.dataset)
  494. # %%
  495. def move_to_cuda(g):
  496. g.x = g.x.cuda()
  497. g.edge_index = g.edge_index.cuda()
  498. g.edge_attr = g.edge_attr.cuda().type(torch.float32)
  499. g.y = g.y.cuda()
  500. return g
  502. # %%
  503. from torch_geometric.nn.norm import LayerNorm, BatchNorm
  504. from torch_geometric.nn import global_add_pool
  505. from torch_geometric.nn import aggr
  506. import sklearn
  507. class PeptideGNN(torch.nn.Module):
  508. def __init__(self, hidden_channels, input_channels=4, gatheads=10, gatdropout=0.5, finaldropout=0.5):
  509. super(PeptideGNN, self).__init__()
  510. self.finaldropout = finaldropout
  511. torch.manual_seed(111)
  512. self.norm = BatchNorm(input_channels)
  513. self.conv1 = GATv2Conv(input_channels, hidden_channels, dropout=gatdropout, heads=gatheads, concat=False, edge_dim=128)
  514. self.pooling = global_mean_pool
  515. self.lin = Linear(hidden_channels, 2)
  516. def forward(self, x, edge_index, edge_attr, batch, hidden=False):
  517. x = self.norm(x)
  518. x = self.conv1(x, edge_index, edge_attr)
  519. x = x.relu()
  520. if hidden:
  521. return x
  522. x = self.pooling(x, batch)
  523. x = F.dropout(x, p=self.finaldropout, training=self.training)
  524. x = self.lin(x)
  525. return x
  527. # %%
  528. gpcr_hits.groupby(['gpcr']).agg({'y': 'sum'}).sort_values(by='y')
  530. # %%
  531. for g in all_graphs:
  532. g['graph'].gpcrweight = torch.tensor(g['gpcrweight']).cuda()
  534. # %%
  535. # original splits (gpcr)
  536. # validation_peptides = [['NPR-43', 'CKR-1', 'NPR-39', 'AEX-2', 'DMSR-2', 'NPR-41'],
  537. # ['NPR-11', 'SPRR-2', 'SPRR-1', 'NPR-10', 'DMSR-3', 'GNRR-6'],
  538. # ['NPR-5', 'DMSR-8', 'NPR-2', 'FRPR-9', 'NPR-42', 'NPR-32'],
  539. # ['FRPR-8', 'NPR-40', 'FRPR-16', 'NPR-1', 'FRPR-6', 'FRPR-4'],
  540. # ['NPR-6', 'NMUR-2', 'FRPR-7', 'NPR-13', 'FRPR-19', 'TRHR-1'],
  541. # ['GNRR-1', 'FRPR-18', 'NPR-37', 'PDFR-1', 'FRPR-3'],
  542. # ['NPR-22', 'EGL-6', 'CKR-2', 'NMUR-1', 'NPR-4', 'FRPR-15'],
  543. # ['NPR-24', 'SEB-3', 'DMSR-6', 'NPR-12', 'DMSR-7'],
  544. # ['GNRR-3', 'NPR-35', 'TKR-2', 'NTR-1', 'DMSR-5'],
  545. # ['NPR-8', 'DMSR-1', 'NPR-3', 'TKR-1']]
  547. #phylogenetic splits (gpcr)
  548. validation_peptides = [['FRPR-16', 'FRPR-18', 'FRPR-4', 'FRPR-6', 'NPR-22', 'NMUR-2'],
  549. ['AEX-2', 'DMSR-5', 'DMSR-6', 'DMSR-7', 'DMSR-8','NPR-32'],
  550. ['FRPR-7', 'FRPR-7', 'NPR-6', 'GNRR-3', 'EGL-6'],
  551. ['TKR-1', 'TKR-2', 'DMSR-1', 'DMSR-2', 'NPR-40', 'GNRR-6'],
  552. ['NPR-42', 'FRPR-9', 'FRPR-15', 'FRPR-19', 'NMUR-1'],
  553. ['NPR-8', 'NPR-24', 'NPR-37', 'NPR-43', 'FRPR-3'],
  554. ['FRPR-8', 'GNRR-1', 'SPRR-1', 'SPRR-2', 'NPR-11', 'NPR-12'],
  555. ['NPR-41', 'NPR-1', 'NPR-2', 'NPR-3', 'PDFR-1', 'NTR-1'],
  556. ['TRHR-1', 'NPR-35', 'NPR-13', 'NPR-5', 'SEB-3'],
  557. ['DMSR-3', 'NPR-10', 'NPR-4', 'NPR-39', 'CKR-1', 'CKR-2']]
  562. # %%
  563. hpt_peptides = validation_peptides[-2:]+validation_peptides[0:-2]
  565. # %%
  566. all_graphs
  568. # %%
  569. test_logits = []
  570. test_labels = []
  571. candidatesgnn = []
  572. hitmapgnn = []
  573. subsampling_factor = 4
  574. average_precisions = dict()
  575. hpt_results = []
  577. for validation_peptide,hpt_peptide in zip(validation_peptides, hpt_peptides):
  578. training_graphs = [g['graph'] for g in all_graphs if g['gpcr_family'] not in validation_peptide and g['y'] == 1]
  579. hpt_training_graphs = [g['graph'] for g in all_graphs if g['gpcr_family'] not in validation_peptide and g['gpcr_family'] not in hpt_peptide and g['y'] == 1]
  580. hpt_to_shuffle = [g['graph'] for g in all_graphs if g['gpcr_family'] not in validation_peptide and g['gpcr_family'] not in hpt_peptide and g['y'] == 0]
  581. to_shuffle = [g['graph'] for g in all_graphs if g['gpcr_family'] not in validation_peptide and g['y'] == 0]
  582. random.Random(111).shuffle(to_shuffle)
  583. random.Random(111).shuffle(hpt_to_shuffle)
  584. trainings = []
  585. hpt_trainings = []
  586. for i in range(20):
  587. random.Random(i).shuffle(to_shuffle)
  588. trainings.append(training_graphs + to_shuffle[0:len(training_graphs)*subsampling_factor])
  589. trainings = [list(map(move_to_cuda, h)) for h in trainings]
  590. random.Random(i).shuffle(hpt_to_shuffle)
  591. hpt_trainings.append(hpt_training_graphs + hpt_to_shuffle[0:len(hpt_training_graphs)*subsampling_factor])
  592. hpt_trainings = [list(map(move_to_cuda, h)) for h in hpt_trainings]
  593. validation_graphs = [g['graph'] for g in all_graphs if g['gpcr_family'] in validation_peptide]
  594. hpt_validation_graphs = [g['graph'] for g in all_graphs if g['gpcr_family'] in hpt_peptide]
  595. validation_graphs = list(map(move_to_cuda, validation_graphs))
  596. hpt_validation_graphs = list(map(move_to_cuda, hpt_validation_graphs))
  597. test_loader = DataLoader(validation_graphs, batch_size=256, shuffle=False)
  598. hpt_test_loader = DataLoader(hpt_validation_graphs, batch_size=256, shuffle=False)
  599. hpt_maps = []
  600. hpt_logits = []
  601. hpt_labels = []
  602. def objective(trial):
  603. hidden_channels = trial.suggest_int('hidden_units', 50, 100)
  604. batch_size = trial.suggest_int('batch_size', 50, 200)
  605. lr = 0.0005
  606. model = PeptideGNN(hidden_channels, input_channels=128).cuda()
  607. optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
  608. criterion = torch.nn.CrossEntropyLoss(label_smoothing=0.5, reduction='none')
  609. for epoch in range(1, 30):
  610. training_graphs = random.Random(epoch+111).choice(hpt_trainings)
  611. train_loader = DataLoader(training_graphs, batch_size=batch_size, shuffle=True)
  612. loss = train_weighted(model, criterion, optimizer, train_loader)
  613. model.eval()
  614. all_logits = []
  615. atrues = []
  616. with torch.no_grad():
  617. for data in hpt_test_loader:
  618. logits = model(data.x, data.edge_index, data.edge_attr, data.batch)
  620. if torch.isnan(data.x).any():
  621. print(f"NaN in node features for {hpt_peptide}")
  622. if torch.isnan(data.edge_attr).any():
  623. print(f"NaN in edge attributes for {hpt_peptide}")
  624. if torch.isinf(data.x).any() or torch.isinf(data.edge_attr).any():
  625. print(f"Infinite values in data for {hpt_peptide}")
  627. # 🧩 Check for NaNs in model output
  628. if torch.isnan(logits).any():
  629. print(f"NaN detected in model output during Optuna eval for {hpt_peptide}")
  630. continue # skip this batch safely
  632. all_logits.append(logits.cpu().detach()[:,1])
  633. atrues.append(data.y.cpu())
  634. hpt_logits.append(np.concatenate(all_logits))
  635. hpt_labels.append(np.concatenate(atrues))
  636. hpt_average_precisions = []
  637. val_gpcr = [g.gpcr for g in hpt_validation_graphs]
  638. val_peptide = [g.peptide for g in hpt_validation_graphs]
  639. result = pd.DataFrame(zip(hpt_labels[-1], hpt_logits[-1], val_gpcr, val_peptide))
  640. for gpcr, r in result.groupby(2):
  641. if r[0].sum() > 0:
  642. if np.isnan(r[0]).any():
  643. print(f"NaNs in TRUE labels for group: {gpcr}")
  644. if np.isnan(r[1]).any():
  645. print(f"NaNs in PREDICTIONS for group: {gpcr}")
  646. hpt_average_precisions.append(sklearn.metrics.average_precision_score(r[0], r[1]))
  647. else:
  648. print('what')
  649. hpt_maps.append((np.mean(hpt_average_precisions), (hidden_channels, batch_size, lr)))
  650. return np.mean(hpt_average_precisions)
  651. sampler = optuna.samplers.RandomSampler(seed=111)
  652. study = optuna.create_study(direction='maximize', sampler=sampler)
  653. study.optimize(objective, n_trials=40)
  654. hpt_results.append(hpt_maps)
  655. _, params = sorted(hpt_maps)[-1]
  656. model = PeptideGNN(params[0], input_channels=128).cuda()
  657. optimizer = torch.optim.AdamW(model.parameters(), lr=params[2])
  658. criterion = torch.nn.CrossEntropyLoss(label_smoothing=0.5, reduction='none')
  659. print(validation_peptide)
  660. for epoch in range(1, 30):
  661. training_graphs = random.Random(epoch+111).choice(trainings)
  662. train_loader = DataLoader(training_graphs, batch_size=params[1], shuffle=True)
  663. loss = train_weighted(model, criterion, optimizer, train_loader)
  664. if epoch % 14 == 0:
  665. test_acc = test_without_crash(model, criterion, test_loader)
  666. print(f'Epoch: {epoch:02d}, Train Acc: {test_without_crash(model, criterion, train_loader):.4f}, Test AUC: {test_acc:.4f}')
  668. torch.save(model.state_dict(), f'{save_to}pretrained_{validation_peptide[0]}.pth')
  670. model.eval()
  671. all_logits = []
  672. atrues = []
  673. with torch.no_grad():
  674. for data in test_loader:
  675. logits = model(data.x, data.edge_index, data.edge_attr, data.batch)
  676. all_logits.append(logits.cpu().detach()[:,1])
  677. atrues.append(data.y.cpu())
  679. test_logits.append(np.concatenate(all_logits))
  680. test_labels.append(np.concatenate(atrues))
  682. val_gpcr = [g.gpcr for g in validation_graphs]
  683. val_peptide = [g.peptide for g in validation_graphs]
  684. result = pd.DataFrame(zip(test_labels[-1], test_logits[-1], val_gpcr, val_peptide))
  685. for gpcr, r in result.groupby(2):
  686. hitmapgnn.append((gpcr, r.sort_values(by=1).iloc[-17:][0].sum()))
  687. candidatesgnn.append((gpcr,r.sort_values(by=1)))
  688. if r[0].sum() > 0:
  689. average_precisions[gpcr] = sklearn.metrics.average_precision_score(r[0], r[1])
  690. print(gpcr, average_precisions[gpcr])
  692. print(roc_auc_score(np.concatenate(test_labels), np.concatenate(test_logits)))
  694. # %%
  695. np.mean(list(average_precisions.values()))
  697. # %%
  698. map_value = int(round(np.mean(list(average_precisions.values())),3)*1000)
  699. st = pd.concat([st for g,st in candidatesgnn])
  700. st.to_csv(f'/content/average_precision_values.csv', index=False)

DeorphaNN_training.ipynb at commit 0ddab30, under MIT · at the source

Overview

Authors: Larissa Ferguson1, Sébastien Ouellet2, Elke Vandewyer3, Christopher Wang2, Zaw Wunna1, Tony KY Lim4, William R Schafer1,3, Isabel Beets3
ORCID iDs: Larissa Ferguson, Sébastien Ouellet, Tony KY Lim, William R Schafer, Isabel Beets
  1. Neurobiology Division, MRC Laboratory of Molecular Biology, Cambridge, UK
  2. Independent Researcher, Ottawa, ON, Canada
  3. Department of Biology, KU Leuven, Leuven, Belgium
  4. Department of Pharmacology, University of Cambridge, Cambridge, UK
Institutions: MRC Laboratory of Molecular Biology (United Kingdom); KU Leuven (Belgium); University of Cambridge (United Kingdom)
Journal: Molecular cell, volume 86, issue 15, pages 3102-3117.e5
Dates: published online 23 July 2026; in print 6 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.molcel.2026.07.006 · PMID 42492505 · PMCID PMC7619462 · OpenAlex W4408742047
Open access: hybrid, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.03.19.644234
Status: code verified
Categories: human (organism), C. elegans (organism), cellular / molecular (subfield)
Methods: Smoothing, state filtering, decompositions, Machine learning, Statistics
Keywords: Neuropeptides, G protein-coupled receptors, Peptide hormone, Structural Bioinformatics, Deorphanization, Protein Representations, Alphafold, Peptide Agonists, Active-state Structures, Protein Embeddings
MeSH: Caenorhabditis elegans Proteins*, Deep Learning*, Drug Discovery*, Peptides*, Receptors, G-Protein-Coupled*, Animals, Caenorhabditis elegans, Graph Neural Networks, Humans, Neuropeptides, Protein Binding (* major topic)
Topic: Receptor Mechanisms and Signaling (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Medical Research Council (MC_U105185857); KU Leuven; UK Research and Innovation Medical Research Council; European Biodiversity Partnership; Research Foundation Flanders
Citations: not cited yet (Europe PMC); 100 references in the paper

Abstract

Peptide-activated G protein-coupled receptors (GPCRs) regulate physiological processes through interaction with neuropeptides and peptide hormones. Identifying endogenous peptide agonists remains challenging, as peptide-GPCR pairings often follow gene-family relationships that offer limited predictive insight for orphan GPCRs without characterized homologs. Using a dataset of experimentally validated peptide-GPCR interactions from Caenorhabditis elegans, we demonstrate that AF-multimer confidence metrics partially discriminate agonist from non-agonist complexes, with improved discrimination using AF-Multistate-derived active-state templates. Feature analysis revealed that AF-multimer’s pair representations outperform single representations, with distinct subregions providing complementary signals. Leveraging these insights, we developed DeorphaNN, a graph neural network integrating active-state GPCR-peptide structural predictions, interatomic interactions, and deep learning embeddings to prioritize putative peptide agonists for experimental screening. DeorphaNN generalized across diverse species, as shown by performance on annelid and human retrospective benchmarks. Experimental validation confirmed predicted agonists for two orphan GPCRs, demonstrating its utility for accelerating peptide-GPCR deorphanization.

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

Repositories

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

Zebreu/DeorphaNN

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 0ddab304da08d48540ce09a3072a5c7d1e5a9b98, 25 June 2026
Languages: Python (7), Jupyter (3)
Size: 13 files, 10 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, license file, environment (requirements.txt), 3 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (7 files), PyTorch (7 files), pandas (5 files), PyTorch Geometric (3 files), Biopython (2 files), h5py (1 file), scikit-learn (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
12 files
At the source: github.com/Zebreu/DeorphaNN

Zenodo 20862123

License: CC-BY-4.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 70 files
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
At the source:

Zenodo 20865768

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (7 files), PyTorch (7 files), pandas (5 files), PyTorch Geometric (3 files), Biopython (2 files), h5py (1 file), scikit-learn (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
12 files
At the source:

Maryam-Haghani/NEFFy

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c6bc480369201d030b7a18243e71fc261c2d1406, 6 May 2026
Languages: JavaScript (93), Python (12), C++ (7), C/C++ (5)
Size: 392 files, 117 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README, license file, CITATION.cff, environment (pyproject.toml, setup.py), documentation
Not found: tests, continuous integration
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
119 files
At the source: github.com/Maryam-Haghani/NEFFy

facebookresearch/esm

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 2b369911bb5b4b0dda914521b9475cad1656b2ac, 27 June 2023
Languages: Python (79), Jupyter (8), Shell (1)
Size: 476 files, 88 scripts
Software Heritage: archived
Found in: the resources table
Holds: README, license file, environment (environment.yml, pyproject.toml, setup.py), tests, 8 notebooks
Not found: CITATION.cff, continuous integration, documentation
Tools: PyTorch (52 files), NumPy (22 files), SciPy (6 files), Matplotlib (4 files), pandas (3 files), PyTorch Geometric (3 files), Biopython (2 files), seaborn (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
90 files
At the source: github.com/facebookresearch/esm

ElofssonLab/FoldDock

License: Apache-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 9a1a26ced4f6b8b9bc65a7ac76999118c292b80d, 18 April 2023
Languages: Python (99), Shell (36), Jupyter (2)
Size: 19,182 files, 137 scripts
Software Heritage: not archived
Found in: the resources table
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (64 files), pandas (26 files), JAX (17 files), TensorFlow (11 files), Biopython (10 files), SciPy (9 files), scikit-learn (4 files), Matplotlib (3 files), seaborn (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
139 files
At the source: gitlab.com/ElofssonLab/FoldDock/

huhlim/alphafold-multistate

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 7014212f2111d82ec0bf19c7cd70441e7c8ef7f2, 12 April 2024
Languages: Python (90), Shell (3), Jupyter (2)
Size: 132 files, 95 scripts
Software Heritage: archived
Found in: the resources table
Holds: README, environment (structure_prediction/requirements.txt), tests, 2 notebooks
Not found: license file, CITATION.cff, continuous integration, documentation
Tools: NumPy (43 files), JAX (29 files), TensorFlow (11 files), Biopython (5 files), SciPy (3 files), Matplotlib (2 files), pandas (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
96 files
At the source: github.com/huhlim/alphafold-multistate

google-deepmind/alphafold

License: Apache-2.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: c77e5d2a8961d1a353632c462914ff0a32a950f6, 22 April 2026
Languages: Python (87), Shell (11), Jupyter (1)
Size: 121 files, 99 scripts
Software Heritage: archived
Found in: the resources table
Holds: README, license file, environment (pyproject.toml, requirements.txt, docker/Dockerfile, docker/requirements.txt), tests, documentation, 1 notebook
Not found: CITATION.cff, continuous integration
Tools: NumPy (43 files), JAX (31 files), TensorFlow (8 files), Biopython (3 files), Matplotlib (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
101 files
At the source: github.com/google-deepmind/alphafold

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:

  • 8 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 556 scripts, each with its path and the digest of its content;
  • 15 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 and code availability

All datasets utilized in this study are available as supplemental materials and in the associated Zenodo repository (DOI: 10.5281/zenodo.20862123 (https://www.doi.org/10.5281/zenodo.20862123)). The DeorphaNN code is available at https://github.com/Zebreu/DeorphaNN (DOI: 10.5281/zenodo.20865768 (https://www.doi.org/10.5281/zenodo.20865768)). Any additional information required to reanalyze the data reported in this paper is available from the lead contact upon request.

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 2, 28 September 2026

  • Publisher: n/a → Elsevier BV
  • Authors: added Sébastien Ouellet (0000-0002-3098-4907); removed Sébastien Ouellet

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 10 keywords, 11 MeSH terms, 5 funders, 99 references.

Cite

This paper

Ferguson, L., Ouellet, S., Vandewyer, E., Wang, C., Wunna, Z., Lim, T. K., Schafer, W. R., & Beets, I. (2026). DeorphaNN: Virtual screening of GPCR peptide agonists using AlphaFold-predicted active-state complexes and deep learning embeddings. Molecular cell, 86(15), 3102-3117.e5. https://doi.org/10.1016/j.molcel.2026.07.006

BibTeX

@article{ferguson2026deorphann,
author = {Ferguson, Larissa and Ouellet, Sébastien and Vandewyer, Elke and Wang, Christopher and Wunna, Zaw and Lim, Tony KY and Schafer, William R and Beets, Isabel},
title = {{DeorphaNN: Virtual screening of GPCR peptide agonists using AlphaFold-predicted active-state complexes and deep learning embeddings}},
journal = {Molecular cell},
year = {2026},
month = jul,
volume = {86},
number = {15},
pages = {3102--3117.e5},
publisher = {Elsevier BV},
issn = {1097-2765},
doi = {10.1016/j.molcel.2026.07.006},
url = {https://doi.org/10.1016/j.molcel.2026.07.006},
pmid = {42492505},
pmcid = {PMC7619462}
}

RIS

TY - JOUR
AU - Ferguson, Larissa
AU - Ouellet, Sébastien
AU - Vandewyer, Elke
AU - Wang, Christopher
AU - Wunna, Zaw
AU - Lim, Tony KY
AU - Schafer, William R
AU - Beets, Isabel
TI - DeorphaNN: Virtual screening of GPCR peptide agonists using AlphaFold-predicted active-state complexes and deep learning embeddings
T2 - Molecular cell
J2 - Mol Cell
PY - 2026
DA - 2026/07/23
VL - 86
IS - 15
SP - 3102
EP - 3117.e5
SN - 1097-2765
PB - Elsevier BV
DO - 10.1016/j.molcel.2026.07.006
UR - https://doi.org/10.1016/j.molcel.2026.07.006
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.molcel.2026.07.006",
"type": "article-journal",
"title": "DeorphaNN: Virtual screening of GPCR peptide agonists using AlphaFold-predicted active-state complexes and deep learning embeddings",
"container-title": "Molecular cell",
"author": [
{
"family": "Ferguson",
"given": "Larissa"
},
{
"family": "Ouellet",
"given": "Sébastien"
},
{
"family": "Vandewyer",
"given": "Elke"
},
{
"family": "Wang",
"given": "Christopher"
},
{
"family": "Wunna",
"given": "Zaw"
},
{
"family": "Lim",
"given": "Tony KY"
},
{
"family": "Schafer",
"given": "William R"
},
{
"family": "Beets",
"given": "Isabel"
}
],
"container-title-short": "Mol Cell",
"volume": "86",
"issue": "15",
"page": "3102-3117.e5",
"DOI": "10.1016/j.molcel.2026.07.006",
"PMID": "42492505",
"PMCID": "PMC7619462",
"ISSN": "1097-2765",
"publisher": "Elsevier BV",
"URL": "https://doi.org/10.1016/j.molcel.2026.07.006",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
23
]
]
}
}

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.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: JAX, Biopython, PyTorch Geometric, 7 other tools, cellular / molecular, 3 references
[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: JAX, Biopython, PyTorch Geometric, 7 other tools, cellular / molecular, 2 references
[3] doi:10.1038/s41586-026-10391-0 [code]
Cell-type-targeted mitochondrial transplantation rescues cell degeneration.
Journal: Nature
In common: JAX, Biopython, PyTorch Geometric, 7 other tools, cellular / molecular, 2 references
[4] doi:10.1038/s41586-026-10670-w [code]
Zero-shot design of drug-binding proteins via neural iterative selection-expansion.
Journal: Nature
In common: PyTorch Geometric, h5py, PyTorch, 6 other tools, cellular / molecular, 4 references
[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: JAX, Biopython, PyTorch Geometric, 7 other tools, cellular / molecular, 1 reference
[6] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: JAX, Biopython, TensorFlow, 7 other tools, cellular / molecular
[7] doi:10.1002/advs.202523984 [code]
INB&lt;sup&gt;3&lt;/sup&gt;P: A Multi-Modal and Interpretable Co-Attention Framework Integrating Property-Aware Explanations and Memory-Bank Contrastive Fusion for Blood-Brain Barrier Penetrating Peptide Discovery.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: Biopython, PyTorch Geometric, PyTorch, 6 other tools, 1 reference
[8] doi:10.1038/s41586-026-10658-6 [code]
An AI system to help scientists write expert-level empirical software.
Journal: Nature
In common: JAX, TensorFlow, h5py, 6 other tools, 1 reference
[9] doi:10.1523/eneuro.0362-25.2026 [code]
Similarities between &lt;i&gt;Ciona&lt;/i&gt; Dorsal Motor Ganglion and Vertebrate Cerebellum: Did a Chordate Ancestor Already Show D/V Subdivision within a Hindbrain Precursor?
Journal: eNeuro
In common: Biopython, PyTorch Geometric, h5py, 7 other tools
[10] doi:10.1016/j.xops.2026.101249 [code]
A Disorder-Aware Computational Framework to Identify Structurally Tractable Targets in Proliferative Vitreoretinopathy.
Journal: Ophthalmology science
In common: JAX, Biopython, TensorFlow, 5 other tools, 1 reference

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.