OSCR

Design, preclinical evaluation, and multicenter phase 1 clinical study of HZ-A-018 for relapsed or refractory central nervous system lymphoma.

Code ↔ Paper

1 match 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 1 match
  1. [1] § Materials and methods › BTK inhibition activity and BBB permeability prediction model ↔ run.py, lines 343–432 · score 0.90 · search spaces, 0.05–0.1, attn_layers, output_dim, batch_size, Hyperopt

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 · 432 lines · 22 KB · MIT · 1 match

  1. import torch, argparse
  2. import torch.nn as nn
  3. import torch.optim as optim
  4. import numpy as np
  5. import pandas as pd
  6. from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, mean_absolute_error, mean_squared_error, r2_score
  7. from torch.nn import BCELoss
  8. from torch_geometric.data import DataLoader
  9. from TFM.Dataset import MolNet
  10. from TFM.model import Kno
  11. from TFM.utils import get_logger, metrics_c, metrics_r, set_seed, load_data
  12. from rdkit.Chem.SaltRemover import SaltRemover
  13. import hyperopt
  14. from hyperopt import fmin, hp, Trials
  15. from hyperopt.early_stop import no_progress_loss
  16. import warnings
  17. from datetime import datetime
  18. warnings.filterwarnings("ignore")
  19. remover = SaltRemover()
  20. bad = ['He', 'Be', 'Na', 'Mg', 'Al', 'K', 'Ca', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Rb', 'Sr', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te', 'Gd', 'Tb', 'Ho', 'W', 'Ir', 'Pt', 'Au', 'Hg', 'Tl', 'Pb', 'Bi', 'Ac']
  21. _use_shared_memory = True
  22. torch.backends.cudnn.benchmark = True
  25. def training(model, train_loader, optimizer, loss_f, metric, task, device, mean, stds):
  26. loss_record, record_count = 0., 0.
  27. preds = torch.Tensor([]); tars = torch.Tensor([])
  28. model.train()
  29. if task == 'clas':
  30. for data in train_loader:
  31. if data.y.size()[0] > 1:
  32. y = data.y.to(device)
  33. logits = model(data)
  35. loss = loss_f(logits.squeeze(), y.squeeze())
  36. loss_record += float(loss.item())
  37. record_count += 1
  38. optimizer.zero_grad()
  39. loss.backward()
  40. nn.utils.clip_grad_value_(model.parameters(), clip_value=2)
  41. optimizer.step()
  43. pred = logits.detach().cpu()
  44. preds = torch.cat([preds, pred], 0); tars = torch.cat([tars, y.cpu()], 0)
  45. clas = preds > 0.5
  46. acc, f1, pre, rec, auc = metric(clas.squeeze().numpy(), preds.squeeze().numpy(), tars.squeeze().numpy())
  47. else:
  48. for data in train_loader:
  49. if data.y.size()[0] > 1:
  50. y = data.y.to(device)
  52. y_ = (y - mean) / (stds+1e-5)
  53. logits = model(data)
  55. loss = loss_f(logits.squeeze(), y_.squeeze())
  56. loss_record += float(loss.item())
  57. record_count += 1
  58. optimizer.zero_grad()
  59. loss.backward()
  60. nn.utils.clip_grad_value_(model.parameters(), clip_value=2)
  61. optimizer.step()
  63. pred = logits.detach()*stds+mean
  64. preds = torch.cat([preds, pred.cpu()], 0); tars = torch.cat([tars, y.cpu()], 0)
  65. acc, f1, pre, rec, auc = metric(preds.squeeze().numpy(), tars.squeeze().numpy())
  67. epoch_loss = loss_record / record_count
  68. return epoch_loss, acc, f1, pre, rec, auc
  71. def testing(model, test_loader, loss_f, metric, task, device, mean, stds, resu):
  72. loss_record, record_count = 0., 0.
  73. preds = torch.Tensor([]); tars = torch.Tensor([])
  74. model.eval()
  75. with torch.no_grad():
  76. if task == 'clas':
  77. for data in test_loader:
  78. if data.y.size()[0] > 1:
  79. y = data.y.to(device)
  80. logits = model(data)
  82. loss = loss_f(logits.squeeze(), y.squeeze())
  83. loss_record += float(loss.item())
  84. record_count += 1
  86. pred = logits.detach().cpu()
  87. preds = torch.cat([preds, pred], 0); tars = torch.cat([tars, y.cpu()], 0)
  88. preds, tars = preds.squeeze().numpy(), tars.squeeze().numpy()
  89. clas = preds > 0.5
  90. acc, f1, pre, rec, auc = metric(clas, preds, tars)
  91. else:
  92. for data in test_loader:
  93. if data.y.size()[0] > 1:
  94. y = data.y.to(device)
  96. y_ = (y - mean) / (stds+1e-5)
  97. logits = model(data)
  99. loss = loss_f(logits.squeeze(), y_.squeeze())
  100. loss_record += float(loss.item())
  101. record_count += 1
  103. pred = logits.detach()*stds+mean
  104. preds = torch.cat([preds, pred.cpu()], 0); tars = torch.cat([tars, y.cpu()], 0)
  105. preds, tars = preds.squeeze().numpy(), tars.squeeze().numpy()
  106. acc, f1, pre, rec, auc = metric(preds, tars)
  108. epoch_loss = loss_record / record_count
  109. if resu:
  110. return epoch_loss, acc, f1, pre, rec, auc, preds, tars
  111. else:
  112. return epoch_loss, acc, f1, pre, rec, auc
  115. def main(tasks, task, dataset, device, train_epoch, seed, fold, batch_size, rate, split, modelpath, logger, lr, attn_head, output_dim, attn_layers, dropout, mean, stds, D, useedge, met, savem):
  116. logger.info('Dataset: {} task: {} train_epoch: {}'.format(dataset, task, train_epoch))
  117. d_k, seed_ = round(output_dim/attn_head), seed
  119. fold_result = [[], []]
  120. if task == 'clas':
  121. loss_f = BCELoss().to(device)
  122. metric = metrics_c(accuracy_score, precision_score, recall_score, f1_score, roc_auc_score)
  124. for fol in range(1, fold+1):
  125. best_val_auc, best_test_auc = 0., 0.
  126. if seed is not None:
  127. seed_ = seed + fol-1
  128. set_seed(seed_)
  129. model = Kno(task, tasks, attn_head, output_dim, d_k, attn_layers, D, dropout, useedge, device).to(device)
  130. optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=0.1)
  131. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50, eta_min=1e-6, last_epoch=-1)
  133. train_loader, valid_loader, test_loader = load_data(dataset, batch_size, rate[0], rate[1], 0, task, split, seed_)
  134. logger.info('Dataset: {} Fold: {:<4d}'.format(moldata, fol))
  136. for i in range(1,train_epoch+1):
  137. train_loss, train_acc, train_f1, train_pre, train_rec, train_auc = training(model, train_loader, optimizer, loss_f, metric, task, device, mean, stds)
  138. if sche:
  139. scheduler.step()
  140. valid_loss, valid_acc, valid_f1, valid_pre, valid_rec, valid_auc = testing(model, valid_loader, loss_f, metric, task, device, mean, stds, False)
  142. logger.info('Dataset: {} Epoch: {:<3d} train_loss: {:.4f} train_auc: {:.4f}'.format(dataset ,i, train_loss, train_auc))
  143. logger.info('Dataset: {} Epoch: {:<3d} valid_loss: {:.4f} valid_auc: {:.4f}'.format(dataset, i, valid_loss, valid_auc))
  145. if valid_auc > best_val_auc:
  146. best_val_auc = valid_auc
  147. if savem:
  148. model_save_path = modelpath + '{}_{}_{}.pkl'.format(dataset, i, round(valid_auc, 4))
  149. torch.save(model.state_dict(), model_save_path)
  150. test_loss, test_acc, test_f1, test_pre, test_rec, test_auc = testing(model, test_loader, loss_f, metric, task, device, mean, stds, False)
  151. logger.info('Dataset: {} Epoch: {:<3d} test__loss: {:.4f} test__auc: {:.4f}'.format(dataset, i, test_loss, test_auc))
  152. best_test_auc = test_auc
  153. fold_result[0].append(best_val_auc)
  154. fold_result[1].append(best_test_auc)
  155. logger.info('Dataset: {} Fold: {} best_val_auc: {:.4f} best_test_auc: {:.4f}'.format(dataset, fol, best_val_auc, best_test_auc))
  156. logger.info('Dataset: {} Fold result: {}'.format(dataset, fold_result))
  157. return fold_result
  159. else:
  160. if met == 'mae':
  161. loss_f = nn.L1Loss().to(device)
  162. else:
  163. loss_f = nn.MSELoss().to(device)
  164. metric = metrics_r(mean_absolute_error, mean_squared_error, r2_score)
  166. for fol in range(1, fold+1):
  167. best_val_rmse, best_test_rmse = 9999., 9999.
  168. if seed is not None:
  169. seed_ = seed + fol-1
  170. set_seed(seed_)
  171. model = Kno(task, tasks, attn_head, output_dim, d_k, attn_layers, D, dropout, useedge, device).to(device)
  172. optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=0.1)
  173. scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50, eta_min=1e-6, last_epoch=-1)
  175. train_loader, valid_loader, test_loader = load_data(dataset, batch_size, rate[0], rate[1], 0, task, split, seed_)
  176. logger.info('Dataset: {} Fold: {:<4d}'.format(moldata, fol))
  178. for i in range(1, train_epoch+1):
  179. train_loss, train_mae, train_rmse, train_r2, _, _ = training(model, train_loader, optimizer, loss_f, metric, task, device, mean, stds)
  180. if sche:
  181. scheduler.step()
  182. valid_loss, valid_mae, valid_rmse, valid_r2, _, _ = testing(model, valid_loader, loss_f, metric, task, device, mean, stds, False)
  183. logger.info('Dataset: {} Epoch: {:<3d} train_loss: {:.4f} train_mae: {:.4f} train_rmse: {:.4f}'.format(dataset, i, train_loss, train_mae, train_rmse))
  184. logger.info('Dataset: {} Epoch: {:<3d} valid_loss: {:.4f} valid_mae: {:.4f} valid_rmse: {:.4f}'.format(dataset, i, valid_loss, valid_mae, valid_rmse))
  186. if met == 'rmse':
  187. if valid_rmse < best_val_rmse:
  188. best_val_rmse = valid_rmse
  189. if savem:
  190. model_save_path = modelpath + '{}_{}_{}.pkl'.format(dataset, i, round(valid_rmse,4))
  191. torch.save(model.state_dict(), model_save_path)
  192. test_loss, test_mae, test_rmse, test_r2, _, _ = testing(model, test_loader, loss_f, metric, task, device, mean, stds, False)
  193. logger.info('Dataset: {} Epoch: {:<3d} test_loss: {:.4f} test_rmse: {:.4f}'.format(dataset, i, test_loss, test_rmse))
  194. best_test_rmse = test_rmse
  196. elif met == 'mae':
  197. if valid_mae < best_val_rmse:
  198. best_val_rmse = valid_mae
  199. if savem:
  200. model_save_path = modelpath + '{}_{}_{}.pkl'.format(dataset, i, round(valid_rmse,4))
  201. torch.save(model.state_dict(), model_save_path)
  202. test_loss, test_mae, test_rmse, test_r2, _, _ = testing(model, test_loader, loss_f, metric, task, device, mean, stds, False)
  203. logger.info('Dataset: {} Epoch: {:<3d} test_loss: {:.4f} test_mae: {:.4f}'.format(dataset, i, test_loss, test_mae))
  204. best_test_rmse = test_mae
  205. else:
  206. raise ValueError('regression metric must be rmse or mae')
  207. fold_result[0].append(best_val_rmse)
  208. fold_result[1].append(best_test_rmse)
  209. logger.info('Dataset: {} Fold: {} best_val_{}: {:.4f} best_test_{}: {:.4f}'.format(dataset, fol, met, best_val_rmse, met, best_test_rmse))
  210. logger.info('Dataset: {} Fold result: {}'.format(dataset, fold_result))
  211. return fold_result
  214. def test(tasks, task, dataset, device, seed, batch_size, logger, attn_head, output_dim, attn_layers, dropout, pretrain, mean, stds, D, useedge, met):
  215. logger.info('Dataset: {} task: {} testing:'.format(dataset, task))
  216. d_k = round(output_dim/attn_head)
  217. if seed is not None:
  218. set_seed(seed)
  219. model = Kno(task, tasks, attn_head, output_dim, d_k, attn_layers, D, dropout, useedge, device).to(device)
  220. state_dict = torch.load(pretrain)
  221. model.load_state_dict(state_dict)
  223. data = MolNet(root='./dataset', dataset=dataset)
  224. loader = DataLoader(data, batch_size=batch_size, shuffle=False, pin_memory=True, num_workers=0, drop_last=False)
  225. if task == 'clas':
  226. loss_f = BCELoss().to(device)
  227. metric = metrics_c(accuracy_score, precision_score, recall_score, f1_score, roc_auc_score)
  228. loss, acc, f1, pre, rec, auc, preds, tars = testing(model, loader, loss_f, metric, task, device, mean, stds, True)
  229. logger.info('Dataset: {} test_loss: {:.4f} test_acc: {:.4f} test_f1: {:.4f} test_auc: {:.4f} test_pre: {:.4f} test_rec: {:.4f}'.format(dataset, loss, acc, f1, auc, pre, rec))
  230. results = {
  231. 'test_loss': loss,
  232. 'test_acc': acc,
  233. 'test_f1': f1,
  234. 'test_pre': pre,
  235. 'test_rec': rec,
  236. 'test_auc': auc,
  237. }
  238. df_prediction = pd.DataFrame({'prediction': preds})
  239. df_target = pd.DataFrame({'target': tars})
  240. df_single_values = pd.DataFrame({k: [v] for k, v in results.items()})
  242. for col in df_single_values.columns:
  243. df_single_values[col] = df_single_values[col].reindex(df_prediction.index, method='ffill')
  245. df = pd.concat([df_single_values, df_prediction, df_target], axis=1)
  246. df.to_csv('log/Result'+moldata+'_test.csv', index=False)
  247. else:
  248. if met == 'mae':
  249. loss_f = nn.L1Loss().to(device)
  250. else:
  251. loss_f = nn.MSELoss().to(device)
  252. metric = metrics_r(mean_absolute_error, mean_squared_error, r2_score)
  253. loss, mae, rmse, r2, _, _, preds, tars= testing(model, loader, loss_f, metric, task, device, mean, stds, True)
  254. logger.info('Dataset: {} test_loss: {:.4f} test_mae: {:.4f} test_rmse: {:.4f} test_r2: {:.4f}'.format(dataset, loss, mae, rmse, r2))
  255. results = {
  256. 'test_loss': loss,
  257. 'test_mae': mae,
  258. 'test_rmse': rmse,
  259. 'test_r2': r2,
  260. }
  261. df_prediction = pd.DataFrame({'prediction': preds})
  262. df_target = pd.DataFrame({'target': tars})
  263. df_single_values = pd.DataFrame({k: [v] for k, v in results.items()})
  265. for col in df_single_values.columns:
  266. df_single_values[col] = df_single_values[col].reindex(df_prediction.index, method='ffill')
  268. df = pd.concat([df_single_values, df_prediction, df_target], axis=1)
  269. df.to_csv('log/Result'+moldata+'_test.csv', index=False)
  272. def psearch(params):
  273. logger.info('Optimizing Hyperparameters')
  274. fold_result = main(params['tasks'],params['task'],params['moldata'],params['device'],params['train_epoch'],params['seed'],params['fold'],params['batch_size'],params['rate'],params['split'],params['modelpath'],params['logger'],params['lr'],params['attn_head'],params['output_dim'],params['attn_layers'],params['dropout'],params['mean'], params['std'], params['D'], params['useedge'], params['metric'], False)
  275. if task == 'reg':
  276. valid_res = np.mean(fold_result[1])
  277. else:
  278. valid_res = -np.mean(fold_result[1])
  279. return valid_res
  282. if __name__ == '__main__':
  283. parser = argparse.ArgumentParser(description='TransFoxMol')
  284. parser.add_argument('mode', type=str, choices=['train', 'test', 'search'], help='train, test or hyperparameter_search')
  285. parser.add_argument('moldata', type=str, help='Dataset name')
  286. parser.add_argument('--task', type=str, choices=['clas', 'reg'], help='Classification or Regression')
  287. parser.add_argument('--numtasks', type=int, default=1, help='Number of tasks (default: 1).')
  288. parser.add_argument('--device', type=str, default='cuda:0', help='Which gpu to use if any (default: cuda:0)')
  289. parser.add_argument('--batch_size', type=int, default=32, help='Input batch size for training (default: 32)')
  290. parser.add_argument('--train_epoch', type=int, default=50, help='Number of epochs to train (default: 50)')
  291. parser.add_argument('--max_eval', type=int, default=100, help='Number hyperparameter settings to try (default: 100)')
  292. parser.add_argument('--lr', type=float, default=0.001, help='learning rate')
  293. parser.add_argument('--valrate', type=float, default=0.1, help='valid rate (default: 0.1)')
  294. parser.add_argument('--testrate', type=float, default=0.1, help='test rate (default: 0.1)')
  295. parser.add_argument('--fold', type=int, default=3, help='Number of folds for cross validation (default: 3)')
  296. parser.add_argument('--dropout', type=float, default=0.05, help='dropout ratio')
  297. parser.add_argument('--split', type =str, default='random_scaffold', help = 'random_scaffold/balan_scaffold/random (default: random_scaffold)')
  298. parser.add_argument('--attn_layers', type=int, default=2, help='Number of feature learning layers')
  299. parser.add_argument('--output_dim', type=int, default=256, help='Hidden size of embedding layer')
  300. parser.add_argument('--D', type=int, default=4, help='Hidden size of readout layer')
  301. parser.add_argument('--seed', type=int, help = "Seed for splitting the dataset")
  302. parser.add_argument('--pretrain', type=str, help = "Path of retrained weights")
  303. parser.add_argument('--metric', type=str, choices=['rmse', 'mae'], help='Metric to evaluate the regression performance')
  304. args = parser.parse_args()
  306. device = torch.device(args.device)
  307. moldata = args.moldata
  308. attn_head = 10
  309. max_eval = args.max_eval
  310. rate = [args.valrate, args.testrate]
  311. useedge = False
  312. sche = True
  314. if moldata in ['esol', 'freesolv', 'lipo', 'qm7', 'qm8', 'qm9']:
  315. task = 'reg'
  316. if moldata == 'qm8':
  317. numtasks = 12
  318. elif moldata == 'qm9':
  319. numtasks = 3
  320. else:
  321. numtasks = 1
  322. elif moldata in ['bbbp', 'sider', 'clintox', 'tox21', 'toxcast', 'bace', 'pcba', 'muv', 'hiv']:
  323. task = 'clas'
  324. if moldata == 'sider':
  325. numtasks = 27
  326. elif moldata == 'clintox':
  327. numtasks = 2
  328. useedge = True
  329. elif moldata == 'tox21':
  330. numtasks = 12
  331. elif moldata == 'toxcast':
  332. numtasks = 617
  333. elif moldata == 'pcba':
  334. numtasks = 128
  335. elif moldata == 'muv':
  336. numtasks = 17
  337. else:
  338. numtasks = 1
  339. else:
  340. task = args.task
  341. numtasks = args.numtasks
  343. logf = 'log/{}_{}_{}_{}.log'.format(moldata, args.task, args.split, args.mode)
  344. modelpath = 'log/checkpoint/'
  345. logger = get_logger(logf)
  347. logger.info("Arguments:")
  348. for arg in vars(args):
  349. logger.info(f"{arg}: {getattr(args, arg)}")
  351. moldata += task
  352. try:
  353. data = MolNet(root='./dataset', dataset=moldata)
  354. except:
  355. raise ValueError('Process the dataset first!')
  356. length = len(data)
  357. if task == 'clas':
  358. mean, std = None, None
  359. else:
  360. max_eval = 50
  361. if numtasks > 1:
  362. ys = np.asarray([d.y.numpy() for d in data])
  363. mean, std = np.mean(ys, 0), np.std(ys, 0)
  364. mean, stds = torch.FloatTensor(mean).to(device), torch.FloatTensor(std).to(device)
  365. else:
  366. ys = np.asarray([d.y.item() for d in data])
  367. mean, std = np.mean(ys, 0), np.std(ys, 0)
  369. dps = [0.05, 0.1]
  370. if args.mode == 'search':
  371. trials = Trials()
  372. if length < 500:
  373. batch_size = 8
  374. attn_head = 8
  375. elif length < 5000:
  376. batch_size = 32
  377. else:
  378. batch_size = 256
  379. max_eval = 50
  380. if task == 'clas':
  381. dps = [0.1, 0.2, 0.3]
  382. if args.moldata == 'bbbp':
  383. lrs = [1e-4, 5e-5, 1e-5]
  384. sche = False
  385. else:
  386. lrs = [1e-2, 5e-3, 1e-3]
  388. parm_space = { # search space of param
  389. 'tasks': numtasks,
  390. 'task': task,
  391. 'moldata': moldata,
  392. 'mean': mean,
  393. 'std': std,
  394. 'device': args.device,
  395. 'modelpath': modelpath,
  396. 'logger': logger,
  397. 'useedge': useedge,
  398. 'seed': args.seed,
  399. 'fold': args.fold,
  400. 'metric': args.metric,
  401. 'rate': rate,
  402. 'split': args.split,
  403. 'train_epoch': args.train_epoch,
  404. 'attn_head': attn_head,
  405. 'output_dim': hp.choice('output_dim', [128, 256]),
  406. 'attn_layers': hp.choice('attn_layers', [1, 2, 3, 4]),
  407. 'dropout': hp.choice('dropout', dps),
  408. 'lr': hp.choice('lr', lrs),
  409. 'D': hp.choice('D', [2, 4, 6, 8, 12, 16]),
  410. 'batch_size': batch_size
  411. }
  412. param_mappings = {
  413. 'output_dim': [128, 256],
  414. 'attn_layers': [1, 2, 3, 4],
  415. 'dropout': dps,
  416. 'lr': lrs,
  417. 'D': [2, 4, 6, 8, 12, 16]
  418. }
  419. best = fmin(fn=psearch, space=parm_space, algo=hyperopt.tpe.suggest, max_evals=max_eval, trials=trials, early_stop_fn=no_progress_loss(int(max_eval/2)))
  420. best_values = {k: param_mappings[k][v] if k in param_mappings else v for k, v in best.items()}
  421. ys = [t['result']['loss'] for t in trials.trials]
  422. logger.info('Dataset {} Hyperopt Results: {}'.format(moldata, ys))
  423. logger.info('Dataset {} Best Params: {}'.format(moldata, best_values))
  424. logger.info('Dataset {} Best Perform: {}'.format(moldata, np.min(ys)))
  426. elif args.mode == 'train':
  427. logger.info('Training')
  428. fold_result = main(numtasks, task, moldata, device, args.train_epoch, args.seed, args.fold, args.batch_size, rate, args.split, modelpath, logger, args.lr, attn_head, args.output_dim, args.attn_layers, args.dropout, mean, std, args.D, useedge, args.metric, True)
  429. elif args.mode == 'test':
  430. assert (args.pretrain is not None)
  431. fold_result = test(numtasks, task, moldata, device, args.seed, args.batch_size, logger, attn_head, args.output_dim, args.attn_layers, args.dropout, args.pretrain, mean, std, args.D, useedge, args.metric)
  432. else:pass

run.py at commit ce054fc, under MIT · at the source

Overview

Authors: Shenglan Li1, Jialiang Lu2,3, Zhuang Kang1, Haiyan Yang4, Wenbin Qian5, Xi Chen4, Xianggui Yuan5, Miao Hu6, Qiuqiu Shi2,3, Xinglu Zhou6, Feng Chen1, Xiaowu Dong2,3, Wenbin Li1
ORCID iDs: Xiaowu Dong
  1. Cancer Center, Beijing Tiantan Hospital, Capital Medical University, Beijing 100070, China
  2. College of Pharmaceutical Sciences, Zhejiang University, Hangzhou 310058, China
  3. ZJUCPS-HealZen Joint Laboratory of Drug Innovation and Transformation, Zhejiang University, Hangzhou 310058, China
  4. Department of Lymphoma, Zhejiang Cancer Hospital, Hangzhou 310022, China
  5. Department of Hematology, The Second Affiliated Hospital, Zhejiang University School of Medicine, Hangzhou 310009, China
  6. HealZen Therapeutics Co., Ltd., Hangzhou 310018, China
Institutions: Capital Medical University (China); Beijing Tian Tan Hospital (China); Zhejiang University (China); Zhejiang Cancer Hospital (China); Second Affiliated Hospital of Zhejiang University (China)
Journal: Acta pharmaceutica Sinica. B, volume 16, issue 8, pages 5351-5362
Dates: received 13 August 2025; accepted 14 April 2026; published online 23 May 2026; in print August 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.apsb.2026.05.021 · PMID 42592300 · PMCID PMC13464085 · OpenAlex W7162195956
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), clinical / translational (subfield)
Methods: Statistics, Connectivity, Machine learning, Smoothing, state filtering, decompositions
Keywords: Bruton tyrosine kinase, Central nervous system lymphoma, BTK inhibitors, HZ-A-018, Blood‒brain barrier, BBB permeability, Phase 1 clinical trial, AI-driven drug discovery
Topic: CNS Lymphoma Diagnosis and Treatment (Neurology, Medicine), according to OpenAlex
Funding: HealZen Therapeutics Co
Citations: not cited yet (Europe PMC); 31 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 1 match between paragraphs and lines of code.

gaojianl/KnoMol

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: ce054fcc139afe2f68fe945be736a5c1bc45cfe8, 26 December 2024
Languages: Python (5)
Size: 14 files, 5 scripts
Software Heritage: not archived
Found in: the text, “BTK inhibition activity and BBB permeability pre”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (4 files), PyTorch Geometric (4 files), PyTorch (4 files), pandas (3 files), RDKit (3 files), NetworkX (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
7 files
At the source: github.com/gaojianl/KnoMol

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;
  • 1 match 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

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

  • Authors: added Xiaowu Dong (0000-0002-2178-4372); removed Xiaowu Dong

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 13 authors, 8 keywords, 1 funder, 31 references.

Cite

This paper

Li, S., Lu, J., Kang, Z., Yang, H., Qian, W., Chen, X., Yuan, X., Hu, M., Shi, Q., Zhou, X., Chen, F., Dong, X., & Li, W. (2026). Design, preclinical evaluation, and multicenter phase 1 clinical study of HZ-A-018 for relapsed or refractory central nervous system lymphoma. Acta pharmaceutica Sinica. B, 16(8), 5351-5362. https://doi.org/10.1016/j.apsb.2026.05.021

BibTeX

@article{li2026design,
author = {Li, Shenglan and Lu, Jialiang and Kang, Zhuang and Yang, Haiyan and Qian, Wenbin and Chen, Xi and Yuan, Xianggui and Hu, Miao and Shi, Qiuqiu and Zhou, Xinglu and Chen, Feng and Dong, Xiaowu and Li, Wenbin},
title = {{Design, preclinical evaluation, and multicenter phase 1 clinical study of HZ-A-018 for relapsed or refractory central nervous system lymphoma}},
journal = {Acta pharmaceutica Sinica. B},
year = {2026},
month = may,
volume = {16},
number = {8},
pages = {5351--5362},
publisher = {Elsevier},
issn = {2211-3835},
doi = {10.1016/j.apsb.2026.05.021},
url = {https://doi.org/10.1016/j.apsb.2026.05.021},
pmid = {42592300},
pmcid = {PMC13464085}
}

RIS

TY - JOUR
AU - Li, Shenglan
AU - Lu, Jialiang
AU - Kang, Zhuang
AU - Yang, Haiyan
AU - Qian, Wenbin
AU - Chen, Xi
AU - Yuan, Xianggui
AU - Hu, Miao
AU - Shi, Qiuqiu
AU - Zhou, Xinglu
AU - Chen, Feng
AU - Dong, Xiaowu
AU - Li, Wenbin
TI - Design, preclinical evaluation, and multicenter phase 1 clinical study of HZ-A-018 for relapsed or refractory central nervous system lymphoma
T2 - Acta pharmaceutica Sinica. B
J2 - Acta Pharm Sin B
PY - 2026
DA - 2026/05/23
VL - 16
IS - 8
SP - 5351
EP - 5362
SN - 2211-3835
PB - Elsevier
DO - 10.1016/j.apsb.2026.05.021
UR - https://doi.org/10.1016/j.apsb.2026.05.021
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.apsb.2026.05.021",
"type": "article-journal",
"title": "Design, preclinical evaluation, and multicenter phase 1 clinical study of HZ-A-018 for relapsed or refractory central nervous system lymphoma",
"container-title": "Acta pharmaceutica Sinica. B",
"author": [
{
"family": "Li",
"given": "Shenglan"
},
{
"family": "Lu",
"given": "Jialiang"
},
{
"family": "Kang",
"given": "Zhuang"
},
{
"family": "Yang",
"given": "Haiyan"
},
{
"family": "Qian",
"given": "Wenbin"
},
{
"family": "Chen",
"given": "Xi"
},
{
"family": "Yuan",
"given": "Xianggui"
},
{
"family": "Hu",
"given": "Miao"
},
{
"family": "Shi",
"given": "Qiuqiu"
},
{
"family": "Zhou",
"given": "Xinglu"
},
{
"family": "Chen",
"given": "Feng"
},
{
"family": "Dong",
"given": "Xiaowu"
},
{
"family": "Li",
"given": "Wenbin"
}
],
"container-title-short": "Acta Pharm Sin B",
"volume": "16",
"issue": "8",
"page": "5351-5362",
"DOI": "10.1016/j.apsb.2026.05.021",
"PMID": "42592300",
"PMCID": "PMC13464085",
"ISSN": "2211-3835",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.apsb.2026.05.021",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
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.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, 4 other tools, clinical / translational
[2] doi:10.1371/journal.pone.0345854 [code]
Shedding light on neural learning to rank models for anticancer drug prioritization.
Journal: PloS one
In common: RDKit, PyTorch Geometric, NetworkX, 4 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, 4 other tools
[4] doi:10.1093/bioinformatics/btag153 [code]
MAISNet: a multi-species integrated graph neural network for acetylcholinesterase inhibitor screening.
Journal: Bioinformatics (Oxford, England)
In common: RDKit, PyTorch Geometric, PyTorch, 3 other tools, clinical / translational
[5] 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, 3 other tools
[6] doi:10.1038/s41586-026-10391-0 [code]
Cell-type-targeted mitochondrial transplantation rescues cell degeneration.
Journal: Nature
In common: RDKit, PyTorch Geometric, PyTorch, 3 other tools
[7] 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, PyTorch, 3 other tools
[8] doi:10.3390/ijms27156614 [code]
Candidalysin Inhibits &lt;i&gt;Porphyromonas gingivalis&lt;/i&gt; Lipoprotein-Induced IL-1β Production in BV-2 Microglia via Hydrophobic Microbial Interactions.
Journal: International journal of molecular sciences
In common: RDKit, PyTorch Geometric, PyTorch, 3 other tools
[9] 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, 3 other tools
[10] doi:10.34133/csbj.0036 [code]
HYG-mol: An Interpretable Multimodal Hypergraph Framework for Molecular Property Prediction.
Journal: Computational and structural biotechnology journal
In common: RDKit, PyTorch Geometric, PyTorch, 3 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.