OSCR

Interpretable deep generative ensemble learning for single-cell omics with Hydra.

Code ↔ Paper

12 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 12 matches · 5 of them tie a paragraph to a whole file, not to given lines: weak matches, whose lines are not tinted
  1. [1] § Methods › Running existing methods › UMINT ↔ Proposed/umint.py, lines 9–60 · score 0.88 · mid_neuron, layer_neuron, lambda_act, lambda_weight, CombinedEncoder, UMINT
  2. [2] § Methods › Running existing methods › scSorterDL ↔ code/scSorterDL_final/train.py, lines 263–320 · score 0.76 · LocalSwarmLDA, cell_sampling, gene_sampling, pred, shrinkage, ldareg
  3. [3] § Methods › Running existing methods › scSorterDL ↔ code/scSorterDL_final/plt_all_submit_query.sh, the whole file · a weak match · score 0.73 · scSorterDL, cell_sampling, gene_sampling, ldareg, uniform, epochs
  4. [4] § Methods › Running existing methods › scPred ↔ Preprocessing/MALT10k_Preprocessing.R, the whole file · a weak match · score 0.72 · FindVariableFeatures, NormalizeData, ScaleData, Seurat, preprocessed, raw
  5. [5] § Methods › Running existing methods › scPred ↔ Benchmarking/Seuratv4/MALT10k_Seurat.R, the whole file · a weak match · score 0.71 · FindVariableFeatures, NormalizeData, ScaleData, Seurat, preprocessed, raw
  6. [6] § Methods › Running existing methods › Statistical tests ↔ R/featureSelection.R, lines 57–101 · score 0.71 · eBayes, lmFit, limma, sum, matrices, model
  7. [7] § Methods › Running existing methods › MOFA+ ↔ Benchmarking/MOFA2/MALT10k_MOFA2.R, the whole file · a weak match · score 0.69 · convergence_mode, model options, train options, MOFA, embeddings, seed
  8. [8] § Methods › Running existing methods › MOFA+ ↔ Benchmarking/MOFA2/bmcite30k_MOFA2.R, the whole file · a weak match · score 0.69 · convergence_mode, model options, train options, MOFA, embeddings, seed
  9. [9] § Methods › Running existing methods › scClassify ↔ vignettes/scClassify.Rmd, lines 132–163 · score 0.64 · selectFeatures, scClassify, cosine, WKNN, HOPACH, algorithm
  10. [10] § Methods › Running existing methods › UMINT ↔ Proposed/autoencoder.py, lines 61–110 · score 0.64 · lambda_act, lambda_weight, encodings, bs, layer, loss
  11. [11] § Methods › Feature ranking module › Refinement and feature ranking ↔ hydra/Hydra.py, lines 334–375 · score 0.64 · refined models, original model, trained model, decoder, epochs, autoencoder
  12. [12] § Results › Joint learning and annotation in diverse single-cell multiome datasets ↔ hydra/Hydra.py, lines 613–664 · score 0.59 · scADT, scATAC, scRNA, CITE, attributed, seq

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 · 734 lines · 37 KB · MIT · 2 matches

  1. #!/usr/bin/python
  3. ##############################################
  5. # Manoj M Wagle (USydney, MIT CSAIL)
  7. ##############################################
  10. import os, sys, random, subprocess
  11. os.environ["RETICULATE_PYTHON"] = sys.executable
  12. import argparse
  13. import logging
  14. import glob
  15. from captum.attr import *
  16. from tqdm import tqdm
  17. import pandas as pd
  18. import numpy as np
  19. import h5py
  20. import pkg_resources
  22. # Logging to Standard Error
  23. Log_Format = "%(levelname)s - %(asctime)s - %(message)s \n"
  24. logging.basicConfig(stream = sys.stderr, format = Log_Format, level = logging.INFO)
  26. ##############################################
  28. # Check if the user requested help for the annotation script
  29. if '--setting' in sys.argv and 'annotation' in sys.argv and ('--help' in sys.argv or '-h' in sys.argv):
  30. annotation_script_path = pkg_resources.resource_filename(__name__, 'Annotation.py')
  31. subprocess.run(["python", annotation_script_path, "--help"])
  32. sys.exit(0)
  34. class CustomHelpFormatter(argparse.RawTextHelpFormatter):
  35. def format_help(self):
  36. help_text = super().format_help()
  37. welcome_message = (
  38. "\nThank you for using Hydra 😄, an interpretable deep generative tool for single-cell omics. Please refer to the full documentation available at https://sydneybiox.github.io/Hydra/ for detailed usage instructions. If you encounter any issues running the tool - Please open an issue on Github, and we will get back to you as soon as possible!!\n\n"
  39. )
  40. Note_message = "\n📍 NOTE 📍: You need to run feature selection (`fs`) on the train datatset before annotating the cell types in the query dataset. If you have already run feature selection on the train & want to annotate (`annotation`) a different related query dataset, please process the data (`processdata`) first and then provide the path to the directory containing this processed data.\n\n"
  42. return welcome_message + Note_message + help_text
  44. # Create argument parser
  45. parser = argparse.ArgumentParser("Hydra", formatter_class=CustomHelpFormatter)
  47. parser.add_argument('--seed', type = int, default = 42, help ='seed')
  49. # Input
  50. parser.add_argument('--train', help='Path to the training dataset (Seurat, SCE or Anndata object)')
  51. parser.add_argument('--test', help='Path to the test dataset (Seurat or SCE object)')
  52. parser.add_argument('--celltypecol', default='cell_type', help='Cell type label column in your input dataset (Seurat, SCE or Anndata object). Default: `cell_type`')
  53. parser.add_argument('--modality', default='rna', choices=['rna', 'adt', 'atac'], help='Input data modality. Default: `rna`')
  54. parser.add_argument('--base_dir', metavar = 'DIR', default=os.getcwd(), help = 'Path to the directory containing processed data directory. Default: Current working directory')
  55. parser.add_argument('--gene', help='Name of the gene whose expression is to be highlighted in the plot')
  56. parser.add_argument('--ctofinterest', help='Name of the cell type for which a ridgeline plot of gene expression should be generated')
  57. parser.add_argument('--predictions', help='Generate UMAP plot for Hydra predicted cell types', default=False)
  58. parser.add_argument('--ctpredictions', help='Path to the csv file containing cell types predicted by Hydra', default=False)
  59. # parser.add_argument('--peak', help='If you are providing peak data for scATAC instead of Gene-activity, filtering will be turned off during data processing. This means that all peaks will be included', default=False)
  60. parser.add_argument('--processdata_batch_size', type = int, default = 1000, help = 'batch size for processing reference and query datasets')
  63. # Training
  64. parser.add_argument('--batch_size', type = int, default = 512, help = 'batch size for processing data during training')
  65. parser.add_argument('--attr_batch_size', type = int, default = 500, help = 'batch size for feature atrribution. Please adjust this based on your GPU memory')
  66. parser.add_argument('--epochs', type = int, default = 40, help = 'num of training epochs')
  67. parser.add_argument('--lr', type = float, default = 0.02, help = 'learning rate')
  69. # GPU specification
  70. parser.add_argument('--gpu', type = str, default = '0', help = 'Please specify the GPU to use')
  72. # Model
  73. parser.add_argument('--z_dim', type = int, default = 100, help = 'Number of neurons in latent space')
  74. parser.add_argument('--hidden_rna', type = int, default = 185, help = 'Number of neurons for RNA layer')
  75. parser.add_argument('--hidden_adt', type = int, default = 30, help = 'Number of neurons for ADT layer')
  76. parser.add_argument('--hidden_atac', type = int, default = 185, help = 'Number of neurons for ATAC layer')
  77. parser.add_argument('--num_models', type = int, default = 25, help= 'Number of models for Ensemble Learning')
  79. # Task
  80. parser.add_argument('--setting', type=str, required=True,
  81. choices=['processdata', 'fs', 'plot', 'annotation'],
  82. help=(
  83. "`processdata` for processing input train and test Seurat, SCE or Anndata objects;\n"
  84. "`fs` for feature selection to obtain cell-identity genes;\n"
  85. "`plot` for generating UMAP plot of the dataset (Additionally, highlights gene expression when called with the `--gene` argument; Generates a ridgeline plot of expression of the specified gene in cell type of interest vs all other cell types when called with `--ctofinterest` argument; Generates a UMAP plot of Hydra predicted labels when called with `--predictions` argument);\n"
  86. "`annotation` for automated annotation of the query dataset\n\n"
  87. )
  88. )
  90. # Capture all remaining arguments for the annotation setting
  91. parser.add_argument('annotation_args', nargs=argparse.REMAINDER, help='Additional arguments for annotation script')
  93. # Parse the command-line arguments
  94. args = parser.parse_args()
  96. if args.gpu:
  97. os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu
  100. ##############################################
  101. # Processing input data
  102. def run_r_script(train_file, test_file, cell_type_label, data_type, processdata_batch_size):
  103. r_command = [
  104. "Rscript",
  105. pkg_resources.resource_filename(__name__, 'R/Process_Dataset.R'),
  106. train_file,
  107. test_file,
  108. cell_type_label,
  109. data_type,
  110. # str(peak),
  111. str(processdata_batch_size)
  112. ]
  113. try:
  114. subprocess.run(r_command, check=True)
  115. except subprocess.CalledProcessError:
  116. print("Error: The R script failed to execute.")
  117. sys.exit(1)
  120. ##############################################
  121. def create_UMAP_plots(rds_file, modality, celltypecol, gene_name=None, ctofinterest=None):
  122. r_command = [
  123. "Rscript",
  124. pkg_resources.resource_filename(__name__, 'R/UMAP_plot.R'),
  125. rds_file,
  126. modality,
  127. celltypecol,
  128. gene_name if gene_name else "None",
  129. ctofinterest if ctofinterest else "None"
  130. ]
  131. try:
  132. subprocess.check_call(r_command)
  133. except subprocess.CalledProcessError as e:
  134. print(f"Error: The R script failed to execute. {e}")
  135. sys.exit(1)
  136. except FileNotFoundError as e:
  137. print(f"Error: File not found. {e}")
  138. sys.exit(1)
  141. ##############################################
  142. def create_UMAP_Hydra_predictions(rds_file, modality, cell_type_predicted):
  143. r_command = [
  144. "Rscript",
  145. pkg_resources.resource_filename(__name__, 'R/plot_predictions.R'),
  146. rds_file,
  147. modality,
  148. cell_type_predicted
  149. ]
  150. try:
  151. subprocess.check_call(r_command)
  152. except subprocess.CalledProcessError as e:
  153. print(f"Error: The R script failed to execute. {e}")
  154. sys.exit(1)
  155. except FileNotFoundError as e:
  156. print(f"Error: File not found. {e}")
  157. sys.exit(1)
  160. ##############################################
  161. # Query dataset annotation
  162. def run_annotation_script(annotation_args):
  163. annotation_command = ["python", pkg_resources.resource_filename(__name__, 'Annotation.py')] + annotation_args
  164. subprocess.run(annotation_command, check=True)
  167. ##############################################
  169. # Import torch-related libraries after setting the CUDA_VISIBLE_DEVICES
  170. import torch
  171. from torch.utils.data import DataLoader
  172. import torch.nn as nn
  173. from .model import (Autoencoder_CITEseq_Step1, Autoencoder_SHAREseq_Step1, Autoencoder_TEAseq_Step1,
  174. Autoencoder_CITEseq_Step2, Autoencoder_SHAREseq_Step2, Autoencoder_TEAseq_Step2,
  175. Autoencoder_RNAseq_Step1, Autoencoder_RNAseq_Step2, Autoencoder_ADTseq_Step1,
  176. Autoencoder_ADTseq_Step2, Autoencoder_ATACseq_Step1, Autoencoder_ATACseq_Step2)
  177. from .train import train_model
  178. from .util import (MyDataset, read_h5_data, Index2Label, read_fs_label,
  179. load_and_preprocess_data, perform_data_augmentation, setup_seed)
  181. # Check the device type based on GPU availability, MPS availability, or defaulting to CPU
  182. device_str = "CUDA" if torch.cuda.is_available() \
  183. else "MPS" if torch.backends.mps.is_built() \
  184. else "CPU"
  185. device = torch.device(device_str.lower())
  187. FloatTensor = torch.FloatTensor
  188. LongTensor = torch.LongTensor
  190. setup_seed(args.seed) ### set seed for reproducbility
  193. ##############################################
  195. print("\nThank you for using Hydra 😄, an interpretable deep generative tool for single-cell omics. Please refer to the full documentation available at https://sydneybiox.github.io/Hydra/ for detailed usage instructions. If you encounter any issues running the tool - Please open an issue on Github, and we will get back to you as soon as possible!!\n\n")
  197. specified_gpus = args.gpu.split(',') if args.gpu else []
  198. num_gpus_specified = len(specified_gpus)
  200. # If CUDA_VISIBLE_DEVICES is not set, use PyTorch to get the total GPU count.
  201. if not specified_gpus:
  202. num_gpus = torch.cuda.device_count()
  203. else:
  204. num_gpus = num_gpus_specified
  206. # Get the indices of GPUs that are currently visible to PyTorch
  207. active_gpu_indices = os.environ.get("CUDA_VISIBLE_DEVICES", "").split(',')
  209. if num_gpus >= 1 and (device_str == "CPU"):
  210. print("It seems the CPU version of PyTorch is installed. For GPU utilization, please install the GPU version of PyTorch. Currently, running on CPU!!!")
  212. print("===============================\n")
  213. print("Device to be used:", device_str, "\n")
  214. print("===============================\n")
  217. ##############################################
  219. def main():
  220. logging.info("Starting to run")
  222. if args.setting.lower() == 'processdata':
  223. if not args.train or not args.modality:
  224. parser.error("--train and --modality are required when --setting is 'processdata'")
  225. else:
  226. # Call the R script to process the data
  227. logging.info("Processing datasets...")
  228. test_file = args.test if args.test else "None"
  229. run_r_script(args.train, test_file, args.celltypecol, args.modality, args.processdata_batch_size)
  231. elif args.setting.lower() == 'plot':
  232. if args.predictions:
  233. if not args.test or not args.modality or not args.ctpredictions:
  234. parser.error("--test, --modality and --ctpredictions are required when --setting is 'plot' and --predictions is True")
  235. else:
  236. # Call the R script to create UMAP plots with predicted cell types
  237. logging.info("Generating plot for Hydra predicted cell types...")
  238. create_UMAP_Hydra_predictions(args.test, args.modality, args.ctpredictions)
  239. else:
  240. if not args.train or not args.modality:
  241. parser.error("--train and --modality are required when --setting is 'UMAPplot'")
  242. else:
  243. # Call the R script to create UMAP plots
  244. logging.info("Generating plot...")
  245. create_UMAP_plots(args.train, args.modality, args.celltypecol, args.gene, args.ctofinterest)
  247. elif args.setting.lower() == 'fs':
  248. dataset_folder_path = os.path.join(args.base_dir, "Input_Processed")
  250. if not os.path.exists(dataset_folder_path):
  251. logging.info(f"Error: The dataset folder '{dataset_folder_path}' does not exist. Please provide path to the directory containing `Input_Processed` directory!!!")
  252. sys.exit(1)
  254. dataset_folders = sorted(glob.glob(f"{args.base_dir}/Input_Processed"))
  256. cwd = os.getcwd()
  258. for dataset_folder in dataset_folders:
  260. logging.info("Training model...")
  262. split_folders = sorted(glob.glob(f"{dataset_folder}/split_*"))
  264. for split_folder in split_folders:
  266. model_save_path = os.path.join(cwd, 'trained_model')
  267. os.makedirs(model_save_path, exist_ok = True)
  269. if os.path.isfile(f"{split_folder}/rna_train.h5"):
  270. args.rna = f"{split_folder}/rna_train.h5"
  271. else:
  272. args.rna = "NULL"
  273. if os.path.isfile(f"{split_folder}/adt_train.h5"):
  274. args.adt = f"{split_folder}/adt_train.h5"
  275. else:
  276. args.adt = "NULL"
  277. if os.path.isfile(f"{split_folder}/atac_train.h5"):
  278. args.atac = f"{split_folder}/atac_train.h5"
  279. else:
  280. args.atac = "NULL"
  281. args.cty = f"{split_folder}/ct_train.csv"
  284. if args.rna != "NULL" and args.adt != "NULL" and args.atac != "NULL":
  285. # Load and preprocess the data
  286. (train_data, train_dl, train_label, mode, classify_dim, nfeatures_rna, nfeatures_adt, nfeatures_atac, feature_num, label_to_name_mapping) = load_and_preprocess_data(args, setting = "train")
  287. logging.info("The Dataset is: scRNA+scADT+scATAC")
  289. if args.rna != "NULL" and args.adt != "NULL" and args.atac == "NULL":
  290. # Load and preprocess the data
  291. (train_data, train_dl, train_label, mode, classify_dim, nfeatures_rna, nfeatures_adt, feature_num, label_to_name_mapping) = load_and_preprocess_data(args, setting = "train")
  292. logging.info("The Dataset is: scRNA+scADT")
  294. if args.rna != "NULL" and args.adt == "NULL" and args.atac != "NULL":
  295. # Load and preprocess the data
  296. (train_data, train_dl, train_label, mode, classify_dim, nfeatures_rna, nfeatures_atac, feature_num, label_to_name_mapping) = load_and_preprocess_data(args, setting = "train")
  297. logging.info("The Dataset is: scRNA+scATAC")
  299. if args.adt == "NULL" and args.atac == "NULL": # scRNA-seq
  300. # Load and preprocess the data
  301. (train_data, train_dl, train_label, mode, classify_dim, nfeatures_rna, feature_num, label_to_name_mapping) = load_and_preprocess_data(args, setting = "train")
  302. logging.info("The Dataset is: scRNA-seq")
  304. if args.atac == "NULL" and args.rna == "NULL": # scADT-Seq
  305. # Load and preprocess the data
  306. (train_data, train_dl, train_label, mode, classify_dim, nfeatures_adt, feature_num, label_to_name_mapping) = load_and_preprocess_data(args, setting = "train")
  307. logging.info("The Dataset is: scADT-seq")
  309. if args.adt == "NULL" and args.rna == "NULL": # scATAC-Seq
  310. # Load and preprocess the data
  311. (train_data, train_dl, train_label, mode, classify_dim, nfeatures_atac, feature_num, label_to_name_mapping) = load_and_preprocess_data(args, setting = "train")
  312. logging.info("The Dataset is: scATAC-seq")
  315. ########## Step 1 ###########
  317. ### Build model
  318. if mode == "scRNA+scADT+scATAC":
  319. model = Autoencoder_TEAseq_Step1(nfeatures_rna, nfeatures_adt, nfeatures_atac, args.hidden_rna, args.hidden_adt, args.hidden_atac, args.z_dim, classify_dim, args.num_models)
  320. elif mode == "scRNA+scADT":
  321. model = Autoencoder_CITEseq_Step1(nfeatures_rna, nfeatures_adt, args.hidden_rna, args.hidden_adt, args.z_dim, classify_dim, args.num_models)
  322. elif mode == "scRNA+scATAC":
  323. model = Autoencoder_SHAREseq_Step1(nfeatures_rna, nfeatures_atac, args.hidden_rna, args.hidden_atac, args.z_dim, classify_dim, args.num_models)
  324. elif mode == "scRNA-seq":
  325. model = Autoencoder_RNAseq_Step1(nfeatures_rna, args.hidden_rna, args.z_dim, classify_dim, args.num_models)
  326. elif mode == "scADT-seq":
  327. model = Autoencoder_ADTseq_Step1(nfeatures_adt, args.hidden_adt, args.z_dim, classify_dim, args.num_models)
  328. elif mode == "scATAC-seq":
  329. model = Autoencoder_ATACseq_Step1(nfeatures_atac, args.hidden_atac, args.z_dim, classify_dim, args.num_models)
  332. model = model.to(device)
  334. # Train the original model on the original raw data including all classifiers
  335. model, loss, train_num = train_model(model, train_dl, lr=args.lr, epochs=args.epochs,
  336. classify_dim=classify_dim, save_path=model_save_path,
  337. save_filename='Original_Model.pth.tar', feature_num=feature_num)
  340. checkpoint_tar = os.path.join(model_save_path, 'Original_Model.pth.tar')
  341. if os.path.exists(checkpoint_tar):
  342. # Load the model's weights
  343. checkpoint = torch.load(checkpoint_tar, weights_only=False)
  344. model = model.module if isinstance(model, nn.DataParallel) else model
  345. model.load_state_dict(checkpoint['state_dict'], strict=True)
  348. ########## Step 2 - Finetuning ###########
  350. min_epochs, max_epochs = 30, 50
  352. for modelI in range(args.num_models):
  354. logging.info("\n\nRefining Model: %s", modelI+1)
  356. if mode == "scRNA+scADT+scATAC":
  357. Step2_model = Autoencoder_TEAseq_Step2(nfeatures_rna, nfeatures_adt, nfeatures_atac, args.hidden_rna, args.hidden_adt, args.hidden_atac, args.z_dim, classify_dim)
  358. elif mode == "scRNA+scADT":
  359. Step2_model = Autoencoder_CITEseq_Step2(nfeatures_rna, nfeatures_adt, args.hidden_rna, args.hidden_adt, args.z_dim, classify_dim)
  360. elif mode == "scRNA+scATAC":
  361. Step2_model = Autoencoder_SHAREseq_Step2(nfeatures_rna, nfeatures_atac, args.hidden_rna, args.hidden_atac, args.z_dim, classify_dim)
  362. elif mode == "scRNA-seq":
  363. Step2_model = Autoencoder_RNAseq_Step2(nfeatures_rna, args.hidden_rna, args.z_dim, classify_dim)
  364. elif mode == "scADT-seq":
  365. Step2_model = Autoencoder_ADTseq_Step2(nfeatures_adt, args.hidden_adt, args.z_dim, classify_dim)
  366. elif mode == "scATAC-seq":
  367. Step2_model = Autoencoder_ATACseq_Step2(nfeatures_atac, args.hidden_atac, args.z_dim, classify_dim)
  369. # Load the encoder weights trained from Step 1
  370. encoder_weights = model.encoder.state_dict()
  371. Step2_model.encoder.load_state_dict(encoder_weights)
  373. # Load the decoder weights trained from Step 1
  374. decoder_weights = model.decoder.state_dict()
  375. Step2_model.decoder.load_state_dict(decoder_weights)
  377. # Load the classifier weights trained from Step 1
  378. classifier_weights = model.classifiers[modelI].state_dict()
  379. Step2_model.classify.load_state_dict(classifier_weights)
  381. # Move the model to GPU and automatically utilize multiple GPUs if available
  382. Step2_model = Step2_model.to(device)
  384. # Generate Augmented dataset
  385. new_data, new_label, new_label_names = perform_data_augmentation(label_to_name_mapping, train_num, classify_dim, train_label, train_data, model, args)
  387. # Process the new data after augmentation
  388. train_transformed_dataset = MyDataset(new_data, new_label)
  390. new_train_dl = DataLoader(train_transformed_dataset, batch_size=args.batch_size, shuffle=True, num_workers=0, drop_last = False)
  392. # set a random number of epochs for this model
  393. epochs = random.randint(min_epochs, max_epochs)
  395. Step2_model, loss, _ = train_model(Step2_model, new_train_dl, lr=args.lr, epochs=epochs,
  396. classify_dim=classify_dim, save_path=model_save_path,
  397. save_filename='FineTuned_Model.pth.tar', feature_num=feature_num)
  399. # Create directory for balanced data if it does not exist
  400. balanced_data_dir = os.path.join(cwd, f'Balanced_Data-{args.num_models}')
  401. os.makedirs(balanced_data_dir, exist_ok = True)
  403. new_data, new_label, new_label_names = perform_data_augmentation(label_to_name_mapping, train_num, classify_dim, train_label, train_data, Step2_model, args)
  405. # Modify new_data_path and new_label_path to use balanced_data_dir
  406. new_data_path = os.path.join(balanced_data_dir, f'train_data_bal_{modelI+1}.pt')
  407. torch.save(new_data, new_data_path)
  409. new_label_path = os.path.join(balanced_data_dir, f'train_label_bal_{modelI+1}.pt')
  410. torch.save(new_label, new_label_path)
  412. # Create directory for final models if it does not exist
  413. final_models_dir = os.path.join(model_save_path, f'Final_Models-{args.num_models}')
  414. os.makedirs(final_models_dir, exist_ok = True)
  416. final_model = Step2_model.module if isinstance(Step2_model, nn.DataParallel) else Step2_model
  418. # Save the final model
  419. final_model_path = os.path.join(final_models_dir, f'model_{modelI+1}.pth.tar')
  420. torch.save({'state_dict': final_model.state_dict()}, final_model_path)
  423. ############ Run feature selection ############
  425. logging.info("\n\nRunning feature selection...")
  427. # Convert feature names to string format
  428. rna_name_new = []
  429. adt_name_new = []
  430. atac_name_new = []
  432. if os.path.isfile(f"{split_folder}/rna_train.h5"):
  433. rna_data_path = f"{split_folder}/rna_train.h5"
  434. rna_data_path_noscale = f"{split_folder}/rna_train_noscale.h5"
  435. else:
  436. rna_data_path = "NULL"
  437. if os.path.isfile(f"{split_folder}/adt_train.h5"):
  438. adt_data_path = f"{split_folder}/adt_train.h5"
  439. adt_data_path_noscale = f"{split_folder}/adt_train_noscale.h5"
  440. else:
  441. adt_data_path = "NULL"
  442. if os.path.isfile(f"{split_folder}/atac_train.h5"):
  443. atac_data_path = f"{split_folder}/atac_train.h5"
  444. atac_data_path_noscale = f"{split_folder}/atac_train_noscale.h5"
  445. else:
  446. atac_data_path = "NULL"
  447. label_path = f"{split_folder}/ct_train.csv"
  449. (label, _) = read_fs_label(label_path)
  451. index_to_label = Index2Label(label_path, classify_dim)
  453. classify_dim = (max(label)+1).cpu().numpy()
  455. if adt_data_path != "NULL" and atac_data_path != "NULL" and rna_data_path != "NULL":
  456. mode = "scRNA+scADT+scATAC"
  458. rna_name = h5py.File(rna_data_path, "r")['matrix/features'][:]
  459. adt_name = h5py.File(adt_data_path, "r")['matrix/features'][:]
  460. atac_name = h5py.File(atac_data_path, "r")['matrix/features'][:]
  462. rna_data = read_h5_data(rna_data_path)
  463. adt_data = read_h5_data(adt_data_path)
  464. atac_data = read_h5_data(atac_data_path)
  466. rna_data_noscale = read_h5_data(rna_data_path_noscale)
  467. adt_data_noscale = read_h5_data(adt_data_path_noscale)
  468. atac_data_noscale = read_h5_data(atac_data_path_noscale)
  470. nfeatures_rna = rna_data.shape[1]
  471. nfeatures_adt = adt_data.shape[1]
  472. nfeatures_atac = atac_data.shape[1]
  474. feature_num = nfeatures_rna + nfeatures_adt + nfeatures_atac
  476. data = torch.cat((rna_data, adt_data, atac_data), 1)
  477. data_noscale = torch.cat((rna_data_noscale, adt_data_noscale, atac_data_noscale), 1)
  479. if args.rna != "NULL" and adt_data_path != "NULL" and atac_data_path == "NULL":
  480. mode = "scRNA+scADT"
  482. rna_name = h5py.File(rna_data_path, "r")['matrix/features'][:]
  483. adt_name = h5py.File(adt_data_path, "r")['matrix/features'][:]
  485. rna_data = read_h5_data(rna_data_path)
  486. adt_data = read_h5_data(adt_data_path)
  488. rna_data_noscale = read_h5_data(rna_data_path_noscale)
  489. adt_data_noscale = read_h5_data(adt_data_path_noscale)
  491. nfeatures_rna = rna_data.shape[1]
  492. nfeatures_adt = adt_data.shape[1]
  494. feature_num = nfeatures_rna + nfeatures_adt
  496. data = torch.cat((rna_data, adt_data), 1)
  497. data_noscale = torch.cat((rna_data_noscale, adt_data_noscale), 1)
  499. if args.rna != "NULL" and adt_data_path == "NULL" and atac_data_path != "NULL":
  500. mode = "scRNA+scATAC"
  502. rna_name = h5py.File(rna_data_path, "r")['matrix/features'][:]
  503. atac_name = h5py.File(atac_data_path, "r")['matrix/features'][:]
  505. rna_data = read_h5_data(rna_data_path)
  506. atac_data = read_h5_data(atac_data_path)
  508. rna_data_noscale = read_h5_data(rna_data_path_noscale)
  509. atac_data_noscale = read_h5_data(atac_data_path_noscale)
  511. nfeatures_rna = rna_data.shape[1]
  512. nfeatures_atac = atac_data.shape[1]
  514. feature_num = nfeatures_rna + nfeatures_atac
  516. data = torch.cat((rna_data, atac_data), 1)
  517. data_noscale = torch.cat((rna_data_noscale, atac_data_noscale), 1)
  519. if adt_data_path == "NULL" and atac_data_path == "NULL":
  520. mode = "scRNA-seq"
  522. rna_name = h5py.File(rna_data_path, "r")['matrix/features'][:]
  524. rna_data = read_h5_data(rna_data_path)
  525. rna_data_noscale = read_h5_data(rna_data_path_noscale)
  527. nfeatures_rna = rna_data.shape[1]
  529. feature_num = nfeatures_rna
  531. data = rna_data
  532. data_noscale = rna_data_noscale
  534. if rna_data_path == "NULL" and atac_data_path == "NULL":
  535. mode = "scADT-seq"
  537. adt_name = h5py.File(adt_data_path, "r")['matrix/features'][:]
  539. adt_data = read_h5_data(adt_data_path)
  540. adt_data_noscale = read_h5_data(adt_data_path_noscale)
  542. nfeatures_adt = adt_data.shape[1]
  544. feature_num = nfeatures_adt
  546. data = adt_data
  547. data_noscale = adt_data_noscale
  549. if rna_data_path == "NULL" and adtdatapath == "NULL":
  550. mode = "scATAC-seq"
  552. atac_name = h5py.File(atac_data_path, "r")['matrix/features'][:]
  554. atac_data = read_h5_data(atac_data_path)
  555. atac_data_noscale = read_h5_data(atac_data_path_noscale)
  557. nfeatures_atac = atac_data.shape[1]
  559. feature_num = nfeatures_atac
  561. data = atac_data
  562. data_noscale = atac_data_noscale
  565. if mode == "scRNA+scADT+scATAC":
  566. for i in range(nfeatures_rna):
  567. a = str(rna_name[i], encoding="utf-8") + "_RNA_"
  568. rna_name_new.append(a)
  569. for i in range(nfeatures_adt):
  570. a = str(adt_name[i], encoding="utf-8") + "_ADT_"
  571. adt_name_new.append(a)
  572. for i in range(nfeatures_atac):
  573. a = str(atac_name[i], encoding="utf-8") + "_ATAC_"
  574. atac_name_new.append(a)
  575. features = rna_name_new + adt_name_new + atac_name_new
  577. if mode == "scRNA+scADT":
  578. for i in range(nfeatures_rna):
  579. a = str(rna_name[i], encoding="utf-8") + "_RNA_"
  580. rna_name_new.append(a)
  581. for i in range(nfeatures_adt):
  582. a = str(adt_name[i], encoding="utf-8") + "_ADT_"
  583. adt_name_new.append(a)
  584. features = rna_name_new + adt_name_new
  586. if mode == "scRNA+scATAC":
  587. for i in range(nfeatures_rna):
  588. a = str(rna_name[i], encoding="utf-8") + "_RNA_"
  589. rna_name_new.append(a)
  590. for i in range(nfeatures_atac):
  591. a = str(atac_name[i], encoding="utf-8") + "_ATAC_"
  592. atac_name_new.append(a)
  593. features = rna_name_new + atac_name_new
  595. if mode == "scRNA-seq":
  596. for i in range(nfeatures_rna):
  597. a = str(rna_name[i], encoding="utf-8") + "_RNA_"
  598. rna_name_new.append(a)
  599. features = rna_name_new
  601. if mode == "scADT-seq":
  602. for i in range(nfeatures_adt):
  603. a = str(adt_name[i], encoding="utf-8") + "_ADT_"
  604. adt_name_new.append(a)
  605. features = adt_name_new
  607. if mode == "scATAC-seq":
  608. for i in range(nfeatures_atac):
  609. a = str(atac_name[i], encoding="utf-8") + "_ATAC_"
  610. atac_name_new.append(a)
  611. features = atac_name_new
  613. # Load all model files
  614. model_files = glob.glob(os.path.join(model_save_path, f'Final_Models-{args.num_models}/*.pth.tar'))
  616. # Run feature selection for each cell type
  617. for i in tqdm(range(classify_dim)):
  619. cell_type_name = index_to_label[i]
  621. try:
  622. cell_type_name = cell_type_name.replace("/", "_")
  623. except:
  624. pass
  626. # Select the data for the current cell type and for all other cell types
  627. current_type_data = data_noscale[torch.where(label == i)].reshape(-1, feature_num)
  628. other_type_data = data_noscale[torch.where(label != i)].reshape(-1, feature_num)
  630. # Calculate the mean expression for each feature across the two groups
  631. mean_current_type = torch.mean(current_type_data, dim=0)
  632. mean_other_types = torch.mean(other_type_data, dim=0)
  634. # Compute fold changes for each feature
  635. epsilon = 1e-6
  636. fold_changes = (mean_current_type + epsilon) / (mean_other_types + epsilon)
  638. # Apply log transformation to fold changes
  639. log_fold_changes = torch.log2(fold_changes)
  641. # Get indices of cells with the current cell type
  642. train_index_fs = torch.where(label == i)
  643. train_index_fs = [t.cpu().numpy() for t in train_index_fs]
  644. train_index_fs = np.array(train_index_fs)
  646. # Get data for the current cell type
  647. train_data_each_celltype_fs = data[train_index_fs, :].reshape(-1, feature_num)
  649. attributions_all_models = []
  651. # Compute the attribution for each cell of the current cell type
  652. for model_file in model_files:
  653. if mode == "scRNA+scADT+scATAC":
  654. model_test = Autoencoder_TEAseq_Step2(nfeatures_rna, nfeatures_adt, nfeatures_atac, args.hidden_rna, args.hidden_adt, args.hidden_atac, args.z_dim, classify_dim)
  655. elif mode == "scRNA+scADT":
  656. model_test = Autoencoder_CITEseq_Step2(nfeatures_rna, nfeatures_adt, args.hidden_rna, args.hidden_adt, args.z_dim, classify_dim)
  657. elif mode == "scRNA+scATAC":
  658. model_test = Autoencoder_SHAREseq_Step2(nfeatures_rna, nfeatures_atac, args.hidden_rna, args.hidden_atac, args.z_dim, classify_dim)
  659. elif mode == "scRNA-seq":
  660. model_test = Autoencoder_RNAseq_Step2(nfeatures_rna, args.hidden_rna, args.z_dim, classify_dim)
  661. elif mode == "scADT-seq":
  662. model_test = Autoencoder_ADTseq_Step2(nfeatures_adt, args.hidden_adt, args.z_dim, classify_dim)
  663. elif mode == "scATAC-seq":
  664. model_test = Autoencoder_ATACseq_Step2(nfeatures_atac, args.hidden_atac, args.z_dim, classify_dim)
  666. # Load the model's weights
  667. checkpoint = torch.load(model_file, weights_only=False)
  668. model_test.load_state_dict(checkpoint['state_dict'], strict=True)
  670. model_test = model_test.to(device)
  672. classify_model = nn.Sequential(*list(model_test.children()))[0:2]
  674. deconv = IntegratedGradients(classify_model)
  676. Attr_batch_size = args.attr_batch_size
  678. # Initialize the attributions tensor
  679. attribution = torch.zeros(1, feature_num).to(device)
  681. # Calculate the attributions in batches
  682. for j in range(0, train_data_each_celltype_fs.size(0), Attr_batch_size):
  683. batch = train_data_each_celltype_fs[j:j + Attr_batch_size, :]
  684. batch = batch.to(device)
  685. attribution += torch.sum(torch.abs(deconv.attribute(batch, target=i)), dim=0, keepdim=True)
  687. # take mean attribution for the current model
  688. attribution_mean = torch.mean(attribution, dim=0)
  689. attributions_all_models.append(attribution_mean)
  691. del model_test # delete the current model to free up memory
  692. torch.cuda.empty_cache() # empty GPU cache to avoid out-of-memory errors
  694. # calculate the average attribution across all models
  695. average_attribution = sum(attributions_all_models) / len(model_files)
  697. fs_score = average_attribution.reshape(-1).detach().cpu().numpy()
  699. # Adjust by the sign of the log fold changes
  700. fs_score = fs_score * np.sign(log_fold_changes.numpy())
  702. # Directly sort by the scores themselves
  703. indices_sorted = np.argsort(-fs_score) # This sorts the scores in descending order
  705. # Use the sorted indices to order your features and scores
  706. fs_results = [features[index] + str(index) for index in indices_sorted]
  707. fs_scores = [fs_score[index] for index in indices_sorted]
  709. # Convert fs_results to a pandas DataFrame
  710. fs_results_df = pd.DataFrame({'Feature Name': fs_results, 'Score': fs_scores})
  712. # Saving feature selection results
  713. cwd = os.getcwd() # Get the current working directory
  714. Hydra_folder = os.path.join(cwd, f"Results/Feature_Selection/Hydra-{args.num_models}")
  716. if not os.path.exists(Hydra_folder):
  717. os.makedirs(Hydra_folder)
  718. # Save the feature selection results to a CSV file
  719. fs_results_df.to_csv(os.path.join(Hydra_folder, f'fs.{cell_type_name}_Hydra.csv'), index=False)
  721. elif args.setting.lower() == "annotation":
  722. run_annotation_script(args.annotation_args)
  724. logging.info("Completed successfully!")
  726. return
  729. ##############################################
  731. if __name__ == "__main__":
  733. # Call the main function
  734. main()

Hydra.py at commit c1b2934, under MIT · at the source

Overview

Authors: Manoj M Wagle1,2,3,4, Chunlei Liu1,2, Zunpeng Liu4,5, Yongheng Wang4,5, Manolis Kellis4,5, Ellis Patrick1,3,6,7, Pengyi Yang1,2,3,6
ORCID iDs: Manoj M Wagle, Manolis Kellis, Ellis Patrick, Pengyi Yang
  1. School of Mathematics and Statistics, Faculty of Science, The University of Sydney,Camperdown, NSW Australia
  2. Computational Systems Biology Unit, Children’s Medical Research Institute, Faculty of Medicine and Health, The University of Sydney,Westmead, NSW Australia
  3. Sydney Precision Data Science Center, The University of Sydney,Camperdown, NSW Australia
  4. Computer Science and Artificial Intelligence Laboratory, Massachusetts Institute of Technology,Cambridge, MA USA
  5. Computational Biology Group, The Broad Institute of MIT and Harvard,Cambridge, MA USA
  6. Charles Perkins Center, The University of Sydney,Camperdown, NSW Australia
  7. Center for Cancer Research, Westmead Institute for Medical Research,Westmead, NSW Australia
Institutions: The University of Sydney (Australia); Massachusetts Institute of Technology (United States); Broad Institute (United States); Westmead Institute for Medical Research (Australia)
Journal: Molecular systems biology, volume 22, issue 7, pages 1161-1179
Dates: received 21 September 2025; accepted 24 March 2026; published online 11 April 2026; in print July 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s44320-026-00208-7 · PMID 41965454 · PMCID PMC13328726 · OpenAlex W4413439263
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.08.15.670517
Status: code verified
Categories: human (organism), cellular / molecular (subfield)
Methods: Connectivity, Spectral & time-frequency, Statistics, Smoothing, state filtering, decompositions, Machine learning
Keywords: Chromatin, Transcription & Genomics, Computational Biology
MeSH: Computational Biology*, Deep Learning*, Single-Cell Analysis*, Autoencoder, Ensemble Learning, Genomics, Humans (* major topic)
Topic: Time Series Analysis and Forecasting (Signal Processing, Computer Science), according to OpenAlex
Funding: National Health and Medical Research Council (1173469)
Citations: not cited yet (Europe PMC); 64 references in the paper

Abstract

Single-cell omics enable the dissection of cellular heterogeneity, yet the high dimensionality, inherent noise, and sparsity present significant challenges. These challenges are amplified for rare cell populations, which are often difficult to annotate reliably but can be central to development and disease. As single-cell assays increasingly capture multiple molecular layers, the integrative analysis of such multimodal data further increases complexity. Here, we propose Hydra, a deep generative framework based on an ensemble of variational autoencoders for effective learning of unimodal and multimodal single-cell omics data. Hydra implements interpretable modules for capturing cell-type-specific molecular signatures. The ensemble of such interpretable modules enables reproducible feature selection and robust cell-type annotation, with particular effectiveness for rare populations. We benchmarked Hydra on a repertoire of 21 datasets, including unimodal and multimodal single-cell omics data. Our results demonstrate that Hydra offers comparable to superior performance to several state-of-the-art methods. Finally, we highlight the utility of Hydra in robustly annotating brain cellular subtypes and preserving disease-relevant signatures using our previously published dataset that profiles Alzheimer’s disease.

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

SydneyBioX/scClassify

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 74fe32784b401492da0fd203736f39bcd6f2a2c5, 20 October 2021
Languages: R (15)
Size: 53 files, 15 scripts
Software Heritage: not archived
Found in: the text, “Methods”
Holds: README, environment (DESCRIPTION), continuous integration, documentation, 2 notebooks
Not found: license file, CITATION.cff, tests
Tools: ggplot2 (2 files), igraph (1 file), limma (1 file), mgcv (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
16 files
At the source: github.com/SydneyBioX/scClassify

kellen8hao/scSorterDL

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: b0c29b000df3d9243f236498e3e15a6df7613995, 7 July 2025
Languages: Shell (9), Python (6)
Size: 31 files, 15 scripts
Software Heritage: not archived
Found in: the text, “Methods”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (4 files), scikit-learn (3 files), Matplotlib (2 files), NumPy (2 files), pandas (2 files), seaborn (2 files)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
16 files
At the source: github.com/kellen8hao/scSorterDL

deeplearner87/UMINT

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 3a588f834dc74879394466147e40378f2d5ad95c, 30 May 2023
Languages: Jupyter (32), R (10), Python (3)
Size: 47 files, 45 scripts
Software Heritage: not archived
Found in: the text, “Methods”
Holds: README, license file, 32 notebooks
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (33 files), pandas (33 files), scikit-learn (28 files), TensorFlow (25 files), Keras (22 files), SciPy (17 files), tidyverse (12 files), Seurat (8 files), Matplotlib (7 files), Scanpy (5 files), cowplot (4 files), data.table (4 files), ggplot2 (4 files), anndata (2 files), patchwork (2 files), pysam (2 files), SingleCellExperiment (2 files), UMAP (2 files)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
47 files
At the source: github.com/deeplearner87/UMINT

SydneyBioX/Hydra

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: c1b293442b30734c8f4a347311a3be106d2373a0, 23 July 2026
Languages: Python (7), R (3)
Size: 42 files, 10 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, license file, environment (pyproject.toml, requirements.txt, setup.py), continuous integration, documentation
Not found: CITATION.cff, tests
Tools: PyTorch (6 files), NumPy (5 files), pandas (4 files), h5py (3 files), reticulate (3 files), SciPy (3 files), Seurat (3 files), SingleCellExperiment (3 files), data.table (2 files), ggplot2 (2 files), Scanpy (2 files), anndata (1 file), Numba (1 file), scikit-learn (1 file)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
12 files
At the source: github.com/SydneyBioX/Hydra

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:

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

Data links

Data availability

The computer code produced in this study is available in the following databases: GitHub (https://github.com/SydneyBioX/Hydra). Documentation for using the tool is available at (https://sydneybiox.github.io/Hydra/).

The source data of this paper are collected in the following database record: biostudies:S-SCDT-10_1038-S44320-026-00208-7 (https://www.ebi.ac.uk/biostudies/sourcedata/studies/S-SCDT-10_1038-S44320-026-00208-7).

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

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 2 keywords, 7 MeSH terms, 1 funder, 56 references.

Cite

This paper

Wagle, M. M., Liu, C., Liu, Z., Wang, Y., Kellis, M., Patrick, E., & Yang, P. (2026). Interpretable deep generative ensemble learning for single-cell omics with Hydra. Molecular systems biology, 22(7), 1161-1179. https://doi.org/10.1038/s44320-026-00208-7

BibTeX

@article{wagle2026interpretable,
author = {Wagle, Manoj M and Liu, Chunlei and Liu, Zunpeng and Wang, Yongheng and Kellis, Manolis and Patrick, Ellis and Yang, Pengyi},
title = {{Interpretable deep generative ensemble learning for single-cell omics with Hydra}},
journal = {Molecular systems biology},
year = {2026},
month = apr,
volume = {22},
number = {7},
pages = {1161--1179},
publisher = {Nature Publishing Group},
issn = {1744-4292},
doi = {10.1038/s44320-026-00208-7},
url = {https://doi.org/10.1038/s44320-026-00208-7},
pmid = {41965454},
pmcid = {PMC13328726}
}

RIS

TY - JOUR
AU - Wagle, Manoj M
AU - Liu, Chunlei
AU - Liu, Zunpeng
AU - Wang, Yongheng
AU - Kellis, Manolis
AU - Patrick, Ellis
AU - Yang, Pengyi
TI - Interpretable deep generative ensemble learning for single-cell omics with Hydra
T2 - Molecular systems biology
J2 - Mol Syst Biol
PY - 2026
DA - 2026/04/11
VL - 22
IS - 7
SP - 1161
EP - 1179
SN - 1744-4292
PB - Nature Publishing Group
DO - 10.1038/s44320-026-00208-7
UR - https://doi.org/10.1038/s44320-026-00208-7
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s44320-026-00208-7",
"type": "article-journal",
"title": "Interpretable deep generative ensemble learning for single-cell omics with Hydra",
"container-title": "Molecular systems biology",
"author": [
{
"family": "Wagle",
"given": "Manoj M"
},
{
"family": "Liu",
"given": "Chunlei"
},
{
"family": "Liu",
"given": "Zunpeng"
},
{
"family": "Wang",
"given": "Yongheng"
},
{
"family": "Kellis",
"given": "Manolis"
},
{
"family": "Patrick",
"given": "Ellis"
},
{
"family": "Yang",
"given": "Pengyi"
}
],
"container-title-short": "Mol Syst Biol",
"volume": "22",
"issue": "7",
"page": "1161-1179",
"DOI": "10.1038/s44320-026-00208-7",
"PMID": "41965454",
"PMCID": "PMC13328726",
"ISSN": "1744-4292",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s44320-026-00208-7",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
11
]
]
}
}

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

Similar papers

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

[1] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: pysam, SingleCellExperiment, limma, 20 other tools, cellular / molecular, 1 reference
[2] 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: Keras, UMAP, anndata, 13 other tools, 7 references
[3] doi:10.1038/s44318-026-00818-9 [code]
FAM134B-mediated ER-phagy degrades APP and suppresses Alzheimer's disease pathology.
Journal: The EMBO journal
In common: SingleCellExperiment, reticulate, limma, 18 other tools, cellular / molecular, 1 reference
[4] doi:10.1038/s41592-026-03194-8 [code]
Beyond benchmarking: an expert-guided consensus approach to spatially aware clustering.
Journal: Nature methods
In common: SingleCellExperiment, limma, anndata, 15 other tools, 4 references
[5] doi:10.1093/bioinformatics/btag652 [code]
mmVelo: a deep generative model for estimating cell state-dependent dynamics across multiple modalities.
Journal: Bioinformatics (Oxford, England)
In common: pysam, UMAP, anndata, 8 other tools, 9 references
[6] doi:10.1016/j.cpblue.2026.100007 [code]
An integrated single-cell and spatial proteotranscriptomics atlas of fibroblast-driven immunoregulation within the human adult oral cavity.
Journal: Cell press blue
In common: SingleCellExperiment, reticulate, limma, 16 other tools, 1 reference
[7] doi:10.1038/s41467-026-71803-3 [code]
Charting the transition from in vitro gliogenesis to the in vivo maturation of human glial progenitor cells transplanted into the hypomyelinated mouse brain.
Journal: Nature communications
In common: reticulate, anndata, Numba, 15 other tools, cellular / molecular, 3 references
[8] doi:10.1016/j.xcrm.2026.102651 [code]
Integrative CSF profiling identifies disease-specific immune responses in leptomeningeal disease.
Journal: Cell reports. Medicine
In common: SingleCellExperiment, reticulate, UMAP, 16 other tools, cellular / molecular
[9] doi:10.1038/s41467-026-76675-1 [code]
Long-read proteogenomic atlas of human neuronal differentiation reveals isoform diversity informing neurodevelopmental risk mechanisms.
Journal: Nature communications
In common: pysam, reticulate, limma, 16 other tools
[10] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: reticulate, limma, Keras, 16 other tools, cellular / molecular

Contribute

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

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

Request its removal

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

Discussion, reproductions, activity

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

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

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