OSCR

Shedding light on neural learning to rank models for anticancer drug prioritization.

Code ↔ Paper

6 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 6 matches
  1. [1] § 2 Materials and methods › 2.2 Loss functions › 2.2.6 NeuralNDCG. ↔ src/models/loss.py, lines 191–272 · score 0.68 · permutation matrix, NeuralNDCG, ground truth, discounted
  2. [2] § 2 Materials and methods › 2.2 Loss functions › 2.2.6 NeuralNDCG. ↔ src/models/loss.py, lines 191–272 · score 0.67 · Sinkhorn scaling, permutation matrix, NeuralNDCG, temperature
  3. [3] § 3 Experiments › 3.2 Explainability setting ↔ src/shapley_listwise.py, lines 35–116 · score 0.62 · background samples, selected genes, SHAP, Kernel, ranking, drugs
  4. [4] § 3 Experiments › 3.1 Experiment setting › 3.1.2 Train-validation setups. ↔ src/cross_validate.py, lines 295–424 · score 0.61 · cross validation, Adam, Python, PyTorch, fold, optimizer
  5. [5] § 2 Materials and methods › 2.2 Loss functions › 2.2.6 NeuralNDCG. ↔ src/models/loss.py, lines 131–189 · score 0.59 · ideal DCG, ground truth, descending
  6. [6] § 3 Experiments › 3.4 Hyperparameter sensitivity and optimization analysis ↔ src/cross_validate.py, lines 295–424 · score 0.56 · NeuralNDCG, LambdaLoss, threshold, optimization, LambdaRank, metrics

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 · 411 lines · 17 KB · no license · 3 matches

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as f
  4. import numpy as np
  5. # import logging
  6. from pathlib import Path
  9. class PairPushLoss(nn.Module):
  10. def __init__(self, alpha=0.5, beta=0.1):
  11. super(PairPushLoss, self).__init__()
  12. self.loss = nn.Softplus(beta=1, threshold=50)
  13. self.relu = nn.ReLU()
  14. self.alpha = alpha
  15. self.beta = beta
  16. #self.gamma = gamma
  18. def forward(self, diff, labels1, labels2, sign):
  19. y = np.array(labels1) == np.array(labels2)
  20. pn_pairs = (y == 0) # for (sens, insens) or (insens, sens) pairs
  21. pp_pairs = (y == 1) & (np.array(labels1) == 1) # for (sens,sens) pairs
  22. nn_pairs = (y == 1) & (np.array(labels1) == 0) # for (insens,insens) pairs
  23. # sign should be 1 if (+,-) pair and -1 if (-,+) pair
  25. bloss = 0
  26. if sum(pp_pairs):
  27. bloss = self.alpha*torch.mean(self.loss(-sign[pp_pairs]*diff[pp_pairs]), dim=0)
  28. if sum(pn_pairs):
  29. bloss += (1-self.alpha-self.beta)*torch.mean(self.loss(-sign[pn_pairs]*diff[pn_pairs]), dim=0)
  30. if sum(nn_pairs):
  31. bloss += self.beta*torch.mean(self.loss(-sign[nn_pairs]*diff[nn_pairs]), dim=0)
  32. return bloss
  34. class ListOneLoss(nn.Module):
  35. def __init__(self, M=1):
  36. super(ListOneLoss, self).__init__()
  37. self.M = M
  39. def forward(self, y_pred, y_true):
  40. pred_max = f.softmax(y_pred/self.M, dim=0) + 1e-9
  41. true_max = f.softmax(-y_true/self.M, dim=0) # need to reverse the sign
  42. pred_log = torch.log(pred_max)
  43. return torch.mean(-torch.sum(true_max*pred_log))
  45. class ListAllLoss(nn.Module):
  46. def __init__(self, M=0.5):
  47. super(ListAllLoss, self).__init__()
  48. self.M = M
  50. def forward(self, y_pred, y_label):
  51. pred_max = f.softmax(y_pred/self.M, dim=1) + 1e-9
  52. pred_log = torch.log(pred_max)
  53. return torch.mean(-torch.sum(y_label*pred_log))
  55. class LambdaLoss(nn.Module):
  56. def __init__(self, eps=1e-10, padded_value_indicator=-1, weighing_scheme=None, k=None, sigma=1.0, mu=10.0,
  57. reduction="mean", reduction_log="binary"):
  58. super(LambdaLoss, self).__init__()
  59. self.eps = eps
  60. self.padded_value_indicator = padded_value_indicator
  61. self.weighing_scheme = weighing_scheme
  62. self.k = k
  63. self.sigma = sigma
  64. self.mu = mu
  65. self.reduction = reduction
  66. self.reduction_log = reduction_log
  68. def forward(self, y_pred, y_true):
  69. device = y_pred.device
  70. y_pred = y_pred.clone()
  71. y_true = y_true.clone()
  73. k = self.k or y_true.shape[1]
  75. y_true = y_true.float()
  76. y_true = (y_true.max()-y_true) + y_true.min()
  78. padded_mask = y_true == self.padded_value_indicator
  79. y_pred[padded_mask] = float("-inf")
  80. y_true[padded_mask] = float("-inf")
  82. y_pred_sorted, indices_pred = y_pred.sort(descending=True, dim=-1)
  83. y_true_sorted, _ = y_true.sort(descending=True, dim=-1)
  85. true_sorted_by_preds = torch.gather(y_true, dim=1, index=indices_pred)
  86. true_diffs = true_sorted_by_preds[:, :, None] - true_sorted_by_preds[:, None, :]
  87. padded_pairs_mask = torch.isfinite(true_diffs)
  89. padded_pairs_mask = padded_pairs_mask & (true_diffs >= 0)
  91. ndcg_at_k_mask = torch.zeros((y_pred.shape[1], y_pred.shape[1]), dtype=torch.bool, device=device)
  92. if k is not None:
  93. ndcg_at_k_mask[:k, :k] = 1
  95. true_sorted_by_preds.clamp_(min=0.)
  96. y_true_sorted.clamp_(min=0.)
  98. pos_idxs = torch.arange(1, y_pred.shape[1] + 1).to(device)
  99. D = torch.log2(1. + pos_idxs.float())[None, :]
  100. maxDCGs = torch.sum(((torch.pow(2, y_true_sorted) - 1) / D)[:, :k], dim=-1).clamp(min=self.eps)
  101. G = (torch.pow(2, true_sorted_by_preds) - 1) / maxDCGs[:, None]
  103. if self.weighing_scheme is None:
  104. weights = 1.0
  105. else:
  106. weights = self.weighing_scheme(G, D, self.mu, true_sorted_by_preds)
  108. scores_diffs = (y_pred_sorted[:, :, None] - y_pred_sorted[:, None, :]).clamp(min=-1e8, max=1e8)
  109. scores_diffs.masked_fill(torch.isnan(scores_diffs), 0.0)
  110. weighted_probas = (torch.sigmoid(self.sigma * scores_diffs).clamp(min=self.eps) ** weights).clamp(min=self.eps)
  112. if self.reduction_log == "natural":
  113. losses = torch.log(weighted_probas)
  114. elif self.reduction_log == "binary":
  115. losses = torch.log2(weighted_probas)
  116. else:
  117. raise ValueError("Reduction logarithm base can be either natural or binary")
  119. if self.reduction == "sum":
  120. loss = -torch.sum(losses[padded_pairs_mask & ndcg_at_k_mask])
  121. elif self.reduction == "mean":
  122. loss = -torch.mean(losses[padded_pairs_mask & ndcg_at_k_mask])
  123. else:
  124. raise ValueError("Reduction method can be either sum or mean")
  126. return loss
  128. def lambdaRank_scheme(G, D, *args):
  129. return torch.abs(torch.pow(D[:, :, None], -1.) - torch.pow(D[:, None, :], -1.)) * torch.abs(G[:, :, None] - G[:, None, :])
  131. class ApproxNDCGLoss(nn.Module):
  132. def __init__(self, eps=1e-10, padded_value_indicator=-1, alpha=1.):
  133. """
  134. :param eps: epsilon value, used for numerical stability
  135. :param padded_value_indicator: an indicator of the y_true index containing a padded item, e.g. -1
  136. :param alpha: score difference weight used in the sigmoid function
  137. """
  138. super(ApproxNDCGLoss, self).__init__()
  139. self.eps = eps
  140. self.padded_value_indicator = padded_value_indicator
  141. self.alpha = alpha
  143. def forward(self, y_pred, y_true):
  144. """
  145. Loss based on approximate NDCG introduced in "A General Approximation Framework for Direct Optimization of
  146. Information Retrieval Measures". Please note that this method does not implement any kind of truncation.
  147. :param y_pred: predictions from the model, shape [batch_size, slate_length]
  148. :param y_true: ground truth labels, shape [batch_size, slate_length]
  149. :return: loss value, a torch.Tensor
  150. """
  151. device = y_pred.device
  152. y_pred = y_pred.clone()
  153. y_true = y_true.clone()
  155. y_true = y_true.float()
  156. y_true = (y_true.max()-y_true) + y_true.min()
  158. padded_mask = y_true == self.padded_value_indicator
  159. y_pred[padded_mask] = float("-inf")
  160. y_true[padded_mask] = float("-inf")
  162. # Here we sort the true and predicted relevancy scores.
  163. y_pred_sorted, indices_pred = y_pred.sort(descending=True, dim=-1)
  164. y_true_sorted, _ = y_true.sort(descending=True, dim=-1)
  166. # After sorting, we can mask out the pairs of indices (i, j) containing index of a padded element.
  167. true_sorted_by_preds = torch.gather(y_true, dim=1, index=indices_pred)
  168. true_diffs = true_sorted_by_preds[:, :, None] - true_sorted_by_preds[:, None, :]
  169. padded_pairs_mask = torch.isfinite(true_diffs)
  170. padded_pairs_mask.diagonal(dim1=-2, dim2=-1).zero_()
  172. # Here we clamp the -infs to get correct gains and ideal DCGs (maxDCGs)
  173. true_sorted_by_preds.clamp_(min=0.)
  174. y_true_sorted.clamp_(min=0.)
  176. # Here we find the gains, discounts and ideal DCGs per slate.
  177. pos_idxs = torch.arange(1, y_pred.shape[1] + 1).to(device)
  178. D = torch.log2(1. + pos_idxs.float())[None, :]
  179. maxDCGs = torch.sum((torch.pow(2, y_true_sorted) - 1) / D, dim=-1).clamp(min=self.eps)
  180. G = (torch.pow(2, true_sorted_by_preds) - 1) / maxDCGs[:, None]
  182. # Here we approximate the ranking positions according to Eqs 19-20 and later approximate NDCG (Eq 21)
  183. scores_diffs = (y_pred_sorted[:, :, None] - y_pred_sorted[:, None, :])
  184. scores_diffs[~padded_pairs_mask] = 0.
  185. approx_pos = 1. + torch.sum(padded_pairs_mask.float() * (torch.sigmoid(-self.alpha * scores_diffs).clamp(min=self.eps)), dim=-1)
  186. approx_D = torch.log2(1. + approx_pos)
  187. approx_NDCG = torch.sum((G / approx_D), dim=-1)
  189. return -torch.mean(approx_NDCG)
  191. class NeuralNDCG(nn.Module):
  192. def __init__(self, padded_value_indicator=-1, temperature=22.0, powered_relevancies=True, k=None,
  193. stochastic=False, n_samples=32, beta=0.1, log_scores=True):
  194. super(NeuralNDCG, self).__init__()
  195. self.padded_value_indicator = padded_value_indicator
  196. self.temperature = temperature
  197. self.powered_relevancies = powered_relevancies
  198. self.k = k
  199. self.stochastic = stochastic
  200. self.n_samples = n_samples
  201. self.beta = beta
  202. self.log_scores = log_scores
  204. def forward(self, y_pred, y_true):
  205. dev = y_pred.device
  207. y_true = y_true.float()
  208. y_true = (y_true.max()-y_true) + y_true.min()
  210. #scalling
  211. y_true = (y_true-y_true.min())/(y_true.max()-y_true.min())
  213. k = self.k or y_true.shape[1]
  214. mask = (y_true == self.padded_value_indicator)
  216. if self.stochastic:
  217. P_hat = stochastic_neural_sort(
  218. y_pred.unsqueeze(-1),
  219. n_samples=self.n_samples,
  220. tau=self.temperature,
  221. mask=mask,
  222. beta=self.beta,
  223. log_scores=self.log_scores,
  224. device=dev,
  225. )
  226. else:
  227. P_hat = deterministic_neural_sort(
  228. y_pred.unsqueeze(-1),
  229. tau=self.temperature,
  230. mask=mask,
  231. device=dev,
  232. ).unsqueeze(0)
  234. # Perform Sinkhorn scaling to obtain doubly stochastic permutation matrices
  235. P_hat = sinkhorn_scaling(
  236. P_hat.view(P_hat.shape[0] * P_hat.shape[1], P_hat.shape[2], P_hat.shape[3]),
  237. mask.repeat_interleave(P_hat.shape[0], dim=0),
  238. tol=1e-6, max_iter=50
  239. )
  240. P_hat = P_hat.view(
  241. int(P_hat.shape[0] / y_pred.shape[0]),
  242. y_pred.shape[0],
  243. P_hat.shape[1],
  244. P_hat.shape[2]
  245. )
  247. P_hat = P_hat.masked_fill(mask[None, :, :, None] | mask[None, :, None, :], 0.0)
  248. y_true_masked = y_true.masked_fill(mask, 0.0).unsqueeze(-1).unsqueeze(0)
  250. if self.powered_relevancies:
  251. y_true_masked = torch.pow(2.0, y_true_masked) - 1.0
  253. ground_truth = torch.matmul(P_hat, y_true_masked).squeeze(-1)
  254. discounts = (torch.tensor(1.0) / torch.log2(torch.arange(y_true.shape[-1], dtype=torch.float) + 2.0)).to(dev)
  255. discounted_gains = ground_truth * discounts
  257. if self.powered_relevancies:
  258. idcg = dcg(y_true, y_true, ats=[k]).permute(1, 0)
  259. else:
  260. idcg = dcg(y_true, y_true, ats=[k], gain_function=lambda x: x).permute(1, 0)
  262. discounted_gains = discounted_gains[:, :, :k]
  263. ndcg = discounted_gains.sum(dim=-1) / (idcg + 1e-10)
  264. idcg_mask = idcg == 0.0
  265. ndcg = ndcg.masked_fill(idcg_mask.repeat(ndcg.shape[0], 1), 0.0)
  267. assert (ndcg < 0.0).sum() == 0, "Every NDCG should be non-negative"
  268. if idcg_mask.all():
  269. return torch.tensor(0.0, device=dev)
  271. mean_ndcg = ndcg.sum() / ((~idcg_mask).sum() * ndcg.shape[0])
  272. return -1.0 * mean_ndcg
  275. def sinkhorn_scaling(mat, mask=None, tol=1e-6, max_iter=50):
  276. """
  277. Sinkhorn scaling procedure.
  278. :param mat: a tensor of square matrices of shape N x M x M, where N is batch size
  279. :param mask: a tensor of masks of shape N x M
  280. :param tol: Sinkhorn scaling tolerance
  281. :param max_iter: maximum number of iterations of the Sinkhorn scaling
  282. :return: a tensor of (approximately) doubly stochastic matrices
  283. """
  284. if mask is not None:
  285. mat = mat.masked_fill(mask[:, None, :] | mask[:, :, None], 0.0)
  286. mat = mat.masked_fill(mask[:, None, :] & mask[:, :, None], 1.0)
  288. for _ in range(max_iter):
  289. mat = mat / mat.sum(dim=1, keepdim=True).clamp(min=1e-10)
  290. mat = mat / mat.sum(dim=2, keepdim=True).clamp(min=1e-10)
  292. if torch.max(torch.abs(mat.sum(dim=2) - 1.)) < tol and torch.max(torch.abs(mat.sum(dim=1) - 1.)) < tol:
  293. break
  295. if mask is not None:
  296. mat = mat.masked_fill(mask[:, None, :] | mask[:, :, None], 0.0)
  298. return mat
  301. def deterministic_neural_sort(s, tau, mask, device="cuda"):
  302. """
  303. Deterministic neural sort.
  304. Code taken from "Stochastic Optimization of Sorting Networks via Continuous Relaxations", ICLR 2019.
  305. Minor modifications applied to the original code (masking).
  306. :param s: values to sort, shape [batch_size, slate_length]
  307. :param tau: temperature for the final softmax function
  308. :param mask: mask indicating padded elements
  309. :return: approximate permutation matrices of shape [batch_size, slate_length, slate_length]
  310. """
  312. n = s.size()[1]
  313. one = torch.ones((n, 1), dtype=torch.float32, device=device)
  314. s = s.masked_fill(mask[:, :, None], -1e8)
  315. A_s = torch.abs(s - s.permute(0, 2, 1))
  316. A_s = A_s.masked_fill(mask[:, :, None] | mask[:, None, :], 0.0)
  318. B = torch.matmul(A_s, torch.matmul(one, torch.transpose(one, 0, 1)))
  320. temp = [n - m + 1 - 2 * (torch.arange(n - m, device=device) + 1) for m in mask.squeeze(-1).sum(dim=1)]
  321. temp = [t.type(torch.float32) for t in temp]
  322. temp = [torch.cat((t, torch.zeros(n - len(t), device=device))) for t in temp]
  323. scaling = torch.stack(temp).type(torch.float32).to(device) # type: ignore
  325. s = s.masked_fill(mask[:, :, None], 0.0)
  326. C = torch.matmul(s, scaling.unsqueeze(-2))
  328. P_max = (C - B).permute(0, 2, 1)
  329. P_max = P_max.masked_fill(mask[:, :, None] | mask[:, None, :], -np.inf)
  330. P_max = P_max.masked_fill(mask[:, :, None] & mask[:, None, :], 1.0)
  331. sm = torch.nn.Softmax(-1)
  332. P_hat = sm(P_max / tau)
  333. return P_hat
  336. def stochastic_neural_sort(s, n_samples, tau, mask, beta=1.0, log_scores=True, eps=1e-10, device="cuda"):
  337. """
  338. Stochastic neural sort. Please note that memory complexity grows by factor n_samples.
  339. Code taken from "Stochastic Optimization of Sorting Networks via Continuous Relaxations", ICLR 2019.
  340. Minor modifications applied to the original code (masking).
  341. :param s: values to sort, shape [batch_size, slate_length]
  342. :param n_samples: number of samples (approximations) for each permutation matrix
  343. :param tau: temperature for the final softmax function
  344. :param mask: mask indicating padded elements
  345. :param beta: scale parameter for the Gumbel distribution
  346. :param log_scores: whether to apply the logarithm function to scores prior to Gumbel perturbation
  347. :param eps: epsilon for the logarithm function
  348. :return: approximate permutation matrices of shape [n_samples, batch_size, slate_length, slate_length]
  349. """
  350. batch_size = s.size()[0]
  351. n = s.size()[1]
  352. s_positive = s + torch.abs(s.min())
  353. samples = beta * sample_gumbel([n_samples, batch_size, n, 1], device=device)
  354. if log_scores:
  355. s_positive = torch.log(s_positive + eps)
  357. s_perturb = (s_positive + samples).view(n_samples * batch_size, n, 1)
  358. mask_repeated = mask.repeat_interleave(n_samples, dim=0)
  360. P_hat = deterministic_neural_sort(s_perturb, tau, mask_repeated)
  361. P_hat = P_hat.view(n_samples, batch_size, n, n)
  362. return P_hat
  365. def dcg(y_pred, y_true, ats=None, gain_function=lambda x: torch.pow(2, x) - 1, padding_indicator=-1):
  366. """
  367. Discounted Cumulative Gain at k.
  369. Compute DCG at ranks given by ats or at the maximum rank if ats is None.
  370. :param y_pred: predictions from the model, shape [batch_size, slate_length]
  371. :param y_true: ground truth labels, shape [batch_size, slate_length]
  372. :param ats: optional list of ranks for DCG evaluation, if None, maximum rank is used
  373. :param gain_function: callable, gain function for the ground truth labels, e.g. torch.pow(2, x) - 1
  374. :param padding_indicator: an indicator of the y_true index containing a padded item, e.g. -1
  375. :return: DCG values for each slate and evaluation position, shape [batch_size, len(ats)]
  376. """
  377. y_true = y_true.clone()
  378. y_pred = y_pred.clone()
  380. actual_length = y_true.shape[1]
  382. if ats is None:
  383. ats = [actual_length]
  384. ats = [min(at, actual_length) for at in ats]
  386. true_sorted_by_preds = __apply_mask_and_get_true_sorted_by_preds(y_pred, y_true, padding_indicator)
  388. discounts = (torch.tensor(1) / torch.log2(torch.arange(true_sorted_by_preds.shape[1], dtype=torch.float) + 2.0)).to(
  389. device=true_sorted_by_preds.device)
  391. gains = gain_function(true_sorted_by_preds)
  393. discounted_gains = (gains * discounts)[:, :np.max(ats)]
  395. cum_dcg = torch.cumsum(discounted_gains, dim=1)
  397. ats_tensor = torch.tensor(ats, dtype=torch.long) - torch.tensor(1)
  399. dcg = cum_dcg[:, ats_tensor]
  401. return dcg
  404. def __apply_mask_and_get_true_sorted_by_preds(y_pred, y_true, padding_indicator=-1):
  405. mask = y_true == padding_indicator
  407. y_pred[mask] = float('-inf')
  408. y_true[mask] = 0.0
  410. _, indices = y_pred.sort(descending=True, dim=-1)
  411. return torch.gather(y_true, dim=1, index=indices)

loss.py at commit 35b0c4b, no license · at the source

Overview

Authors: Faraz Sarmeili1,2, Benyamin Ghahremani-Nezhad3, Mohammad Khalilpour3, Karim Abbasi4, Rassoul Dinarvand1,5, Hamid R Rabiee2
ORCID iDs: Karim Abbasi, Hamid R Rabiee
  1. Department of Pharmaceutics, Faculty of Pharmacy, Tehran University of Medical Sciences, Tehran, Iran
  2. Department of Computer Engineering, Sharif University of Technology, Tehran, Iran
  3. Department of Computer Engineering, Amirkabir University of Technology, Tehran, Iran
  4. Mosaheb Institute for Mathematical Research, Kharazmi University, Tehran, Iran
  5. Nanotechnology Research Centre, Faculty of Pharmacy, Tehran University of Medical Sciences, Tehran, Iran
Institutions: Sharif University of Technology (Iran); Tehran University of Medical Sciences (Iran); Amirkabir University of Technology (Iran); Kharazmi University (Iran)
Journal: PloS one, volume 21, issue 8, article e0345854
Dates: received 2 December 2025; accepted 11 March 2026; published online 13 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pone.0345854 · PMID 42594139 · PMCID PMC13472410 · OpenAlex W7202350312
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), other condition (population)
Methods: Statistics, Machine learning
MeSH: Antineoplastic Agents*, Neural Networks, Computer*, Breast Neoplasms, Cell Line, Tumor, Female, Humans (* major topic)
Topic: Computational Drug Discovery Methods (Computational Theory and Mathematics, Computer Science), according to OpenAlex
Citations: not cited yet (Europe PMC); 63 references in the paper

Abstract

Learning to Rank (LeToR) methods have gained increasing attention in drug response prediction, offering a direct way to prioritize effective treatments for cancer cell lines. In this study, we systematically benchmark six ranking loss functions, including state-of-the-art listwise methods, and five types of molecular representations across two large-scale drug screening datasets, CTRP and PRISM. Using high-dimensional gene expression profiles and various drug fingerprints and descriptors, we evaluated models under multiple validation setups and ranking metrics. Our results demonstrate that listwise loss functions such as LambdaLoss and LambdaRank consistently excel in both early and overall ranking quality. Additionally, combining molecular fingerprints with physicochemical descriptors yielded improved performance. A novel attention-based mechanism and a modified version of RankingSHAP were integrated to enhance interpretability, uncovering key genes and substructures aligned with known biological insights. The explainability pipeline successfully distinguished estrogen receptor-positive (ER⁺) and estrogen receptor-negative (ER−) breast cancer subtypes. The model successfully identified critical substructures in docetaxel, an FDA-approved therapy, and triptolide, which is currently undergoing clinical evaluation for breast cancer. These findings are consistent with established structure-activity relationship (SAR) data. Overall, this study presents a comprehensive evaluation framework and underscores the importance of carefully selecting loss functions and feature representations when developing robust and interpretable drug-ranking systems.

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 6 matches between paragraphs and lines of code.

Sarmeili/NeuralDrugRanker

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 35b0c4b4df6d2a2148f35ac9ce6797300549de26, 8 April 2025
Languages: Python (35), Shell (12), Jupyter (1)
Size: 54 files, 48 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README, 1 notebook
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (32 files), PyTorch (17 files), pandas (12 files), Matplotlib (6 files), RDKit (6 files), scikit-learn (6 files), SciPy (5 files), NetworkX (2 files), PyTorch Geometric (2 files), seaborn (2 files), SHAP (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
49 files
At the source: github.com/Sarmeili/NeuralDrugRanker

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;
  • 48 scripts, each with its path and the digest of its content;
  • 6 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

https://github.com/Sarmeili/NeuralDrugRanker.

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

Recorded: type, language, journal, volume, issue, pages, dates, 6 authors, 6 MeSH terms, 53 references.

Cite

This paper

Sarmeili, F., Ghahremani-Nezhad, B., Khalilpour, M., Abbasi, K., Dinarvand, R., & Rabiee, H. R. (2026). Shedding light on neural learning to rank models for anticancer drug prioritization. PloS one, 21(8), e0345854. https://doi.org/10.1371/journal.pone.0345854

BibTeX

@article{sarmeili2026shedding,
author = {Sarmeili, Faraz and Ghahremani-Nezhad, Benyamin and Khalilpour, Mohammad and Abbasi, Karim and Dinarvand, Rassoul and Rabiee, Hamid R},
title = {{Shedding light on neural learning to rank models for anticancer drug prioritization}},
journal = {PloS one},
year = {2026},
month = aug,
volume = {21},
number = {8},
pages = {e0345854},
publisher = {PLOS},
issn = {1932-6203},
doi = {10.1371/journal.pone.0345854},
url = {https://doi.org/10.1371/journal.pone.0345854},
pmid = {42594139},
pmcid = {PMC13472410}
}

RIS

TY - JOUR
AU - Sarmeili, Faraz
AU - Ghahremani-Nezhad, Benyamin
AU - Khalilpour, Mohammad
AU - Abbasi, Karim
AU - Dinarvand, Rassoul
AU - Rabiee, Hamid R
TI - Shedding light on neural learning to rank models for anticancer drug prioritization
T2 - PloS one
J2 - PLoS One
PY - 2026
DA - 2026/08/13
VL - 21
IS - 8
SP - e0345854
SN - 1932-6203
PB - PLOS
DO - 10.1371/journal.pone.0345854
UR - https://doi.org/10.1371/journal.pone.0345854
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pone.0345854",
"type": "article-journal",
"title": "Shedding light on neural learning to rank models for anticancer drug prioritization",
"container-title": "PloS one",
"author": [
{
"family": "Sarmeili",
"given": "Faraz"
},
{
"family": "Ghahremani-Nezhad",
"given": "Benyamin"
},
{
"family": "Khalilpour",
"given": "Mohammad"
},
{
"family": "Abbasi",
"given": "Karim"
},
{
"family": "Dinarvand",
"given": "Rassoul"
},
{
"family": "Rabiee",
"given": "Hamid R"
}
],
"container-title-short": "PLoS One",
"volume": "21",
"issue": "8",
"page": "e0345854",
"DOI": "10.1371/journal.pone.0345854",
"PMID": "42594139",
"PMCID": "PMC13472410",
"ISSN": "1932-6203",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pone.0345854",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
13
]
]
}
}

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.0184 [code]
Cross-Species Multitask Learning with Molecular and ADME Descriptors for Liver Microsomal Metabolic Stability.
Journal: Computational and structural biotechnology journal
In common: RDKit, PyTorch Geometric, SHAP, 5 other tools, 1 reference
[2] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: RDKit, SHAP, NetworkX, 7 other tools
[3] 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, NetworkX, 7 other tools
[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: RDKit, PyTorch Geometric, PyTorch, 6 other tools
[5] doi:10.3390/ph19081319 [code]
DeepBBB: A Data-Composition-Aware Graph Screening Workflow for BBB-Focused CNS Library Construction and Prospective PAMPA-BBB Evaluation.
Journal: Pharmaceuticals (Basel, Switzerland)
In common: RDKit, PyTorch Geometric, NetworkX, 5 other tools
[6] doi:10.1038/s41398-026-04101-7 [code]
Using deep learning to identify brain networks mediating cognitive and motor impairments in alcohol use disorder.
Journal: Translational psychiatry
In common: PyTorch Geometric, NetworkX, PyTorch, 6 other tools, other condition
[7] doi:10.1038/s41467-026-71759-4 [code]
CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning.
Journal: Nature communications
In common: PyTorch Geometric, NetworkX, PyTorch, 6 other tools, other condition
[8] 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: PyTorch Geometric, SHAP, PyTorch, 6 other tools
[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, 5 other tools, other condition
[10] doi:10.1186/s13321-026-01177-7 [code]
A pipeline for developing AI-driven models to predict molecular initiating events: a case study on neural tube defects.
Journal: Journal of cheminformatics
In common: RDKit, NetworkX, 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.