OSCR

Single-cell trajectory inference for detecting transient events in biological processes.

Code ↔ Paper

10 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 10 matches
  1. [1] § Methods › Cell cycle ↔ cellcycle.ipynb, lines 112–186 · score 0.90 · n_neighbors, n_pcs, score_genes_cell_cycle, Scanpy, ARPACK, PCA
  2. [2] § Methods › Comparison against other methods › tradeSeq ↔ method_evaluations/method_eval.py, lines 138–188 · score 0.83 · associationTest, cellWeights, evaluateK, tradeSeq, eigen, Signal genes
  3. [3] § Results › Induced neuron dataset ↔ sctransient_ineuron.ipynb, lines 775–886 · score 0.72 · cumulative recovery, TES ranked, pathway leading, diagonal, GSEA, fraction
  4. [4] § Results › Cell cycle dataset ↔ cellcycle.ipynb, lines 724–798 · score 0.69 · Leiden clustering, cell cycle phase, Scanpy, 1–3, G2, G1
  5. [5] § Methods › Synthetic data parameters ↔ method_evaluations/method_execution.py, lines 27–116 · score 0.61 · noise genes, Signal genes, Autocorrelation, uniform, amplitude, density
  6. [6] § Methods › Synthetic data parameters ↔ method_evaluations/params.py, lines 10–28 · score 0.61 · noise genes, Signal genes, Autocorrelation, uniform, amplitude, density
  7. [7] § Methods › Transient-event score ↔ cellcycle.ipynb, lines 112–186 · score 0.60 · wavelet transform, scoring genes, pseudotime signal, modified, Gene expression, transient
  8. [8] § Results › Comparison with other methods ↔ method_evaluations/method_exectime_plot.ipynb, lines 93–111 · score 0.53 · GPfates, tradeSeq, scTransient, execution, log
  9. [9] § Methods › Comparison against other methods ↔ method_evaluations/method_execution.py, lines 27–116 · score 0.51 · signal genes, amplitudes, GPfates, widths, noise, Gaussian
  10. [10] § Results › Cell cycle dataset ↔ cellcycle.ipynb, lines 724–798 · score 0.50 · Cell cycle phase, UMAP, Leiden, G2, G1, Clusters

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 878 lines · 30 KB · no license · 4 matches

  1. # %% [markdown]
  2. # # Cell cycle dataset
  3. #
  4. # This notebook is part of the paper titled, "Single-Cell Trajectory Inference for Detecting Transient Events in Biological Processes" by Hutton and Meyer. The data is from the 2025 Bubis et al. paper titled, "[Challenging the Astral mass analyzer to quantify up to 5,300 proteins per single cell at unseen accuracy to uncover cellular heterogeneity](https://doi.org/10.1038/s41592-024-02559-1)".
  6. # %%
  7. import numpy as np
  8. import pandas as pd
  9. from importlib import reload
  10. from matplotlib import pyplot as plt
  11. import scanpy as sc
  12. import anndata as ad
  13. import pypsupertime
  14. from pypsupertime import Psupertime
  15. from typing import Union
  16. from anndata import AnnData
  17. import os
  18. import pickle as pkl
  19. from datetime import datetime
  20. date_str = datetime.now().strftime("%Y_%m_%d")
  21. r_dir = f"{date_str}_cellcycle_unsup"
  22. if not os.path.exists(r_dir):
  23. os.mkdir(r_dir)
  25. # %%
  26. import scTransient
  27. from scTransient.windowing import Window
  28. from scTransient.wavelets import get_scored_wavelet_across_sigs, WaveletTransform
  29. from scTransient.metrics import modified_z_score
  31. # %%
  32. def load_astral(filepath: str = "astral-scp-report.pg_matrix.tsv"):
  33. df = pd.read_csv(filepath, index_col=2, sep='\t')
  34. df = df.iloc[:, 3:] # Drop the first three columns
  35. # Check the structure of the AnnData object
  36. df.fillna(0, inplace=True)
  37. return sc.AnnData(df.T)
  39. # %%
  40. def _normalize_to_endtime(x):
  41. return (x - np.min(x)) / (np.max(x) - np.min(x))
  43. def window_trajectory(adata: AnnData,
  44. trajectory: list,
  45. normalize_to_endtime: bool = True,
  46. window: Union[str] = "gaussian",
  47. window_params: dict = None,
  48. pseudotime_col: str = "dpt_pseudotime",
  49. node_col: str = "leiden",
  50. exclude_minimum: bool = False,
  51. exclude_ends: int = None):
  52. # initialize window
  53. window = _init_window(window, window_params)
  55. # Get pseudotime positions; limit to nodes in trajectory
  56. if trajectory is not None:
  57. retain_idx = adata.obs[node_col].isin(trajectory)
  58. else:
  59. retain_idx = np.ones(adata.shape[0], dtype=bool)
  60. pseudotime = adata.obs.loc[retain_idx, pseudotime_col]
  62. if normalize_to_endtime:
  63. pseudotime = _normalize_to_endtime(pseudotime)
  64. # print(sum(retain_idx))
  65. if exclude_ends is None:
  66. return window.apply(positions=pseudotime,
  67. values=adata.X[retain_idx, :],
  68. exclude_minimum=exclude_minimum)
  70. pseudotime_signals = window.apply(positions=pseudotime,
  71. values=adata.X[retain_idx, :],
  72. exclude_minimum=exclude_minimum)
  73. return pseudotime_signals[exclude_ends:-exclude_ends, :]
  75. def _init_window(window: Union[str, Window],
  76. window_params: dict = None):
  77. if issubclass(window.__class__, str):
  78. if window.lower() == "gaussian":
  79. if window_params is None:
  80. window_params = {"n_windows": 25, "sigma": 0.2}
  81. window = GaussianWindow(**window_params)
  82. elif window.lower() == "rect":
  83. if window_params is None:
  84. window_params = {"n_windows": 25, "width": 0.1}
  85. window = RectWindow(**window_params)
  86. else:
  87. raise ValueError(f"Unrecognized window type: {window}")
  88. return window
  90. def std_from_median(coefs):
  91. """Compute the number of standard deviations from the median of the wavelet coefficients."""
  92. s = np.std(coefs)
  93. if s > 0:
  94. return (coefs - np.median(coefs)) / s
  95. else:
  96. return None
  98. def modified_z_score_with_scaletime(coefs, get_st: bool = False):
  99. zmod = std_from_median(coefs)
  100. if zmod is None:
  101. if not get_st:
  102. return 0
  103. else:
  104. return 0, [None, None]
  105. else:
  106. scale, time = np.unravel_index(np.argmax(zmod), zmod.shape)
  107. if not get_st:
  108. return np.abs(coefs[scale,time] * zmod[scale,time])
  109. else:
  110. return np.abs(coefs[scale,time] * zmod[scale,time]), [scale, time]
  112. # %%
  113. def pipeline_astral_cellcycle(data_loader,
  114. window=None,
  115. window_params: dict = None,
  116. trajectory: list = None,
  117. scoring_threshold: float = 1,
  118. exclude_pt_ends: tuple = (0.05, 0.95),
  119. repeat: bool = False,
  120. save_name: str = None,
  121. coverage_threshold: float = 0.0,
  122. ) -> sc.AnnData:
  123. if save_name is not None:
  124. if os.path.exists(save_name) and not repeat:
  125. adata = sc.read_h5ad(save_name)
  126. else:
  127. adata = data_loader()
  128. print("Preprocessing...")
  129. sc.pp.filter_cells(adata, min_genes=2000, inplace=True)
  130. sc.pp.filter_genes(adata, min_cells=3, inplace=True)
  131. sc.pp.normalize_total(adata, inplace=True, target_sum=1e4)
  132. sc.pp.log1p(adata)
  133. sc.pp.regress_out(adata, ['n_genes'])
  134. sc.pp.scale(adata, max_value=10)
  135. sc.pp.pca(adata, svd_solver="arpack")
  136. sc.pp.neighbors(adata, n_neighbors=10, n_pcs=40)
  137. sc.tl.leiden(adata, resolution=1)
  139. print("Computing pseudotime...")
  140. f = open("regev_lab_cell_cycle_genes.txt", "r")
  141. cell_cycle_genes = [x.strip() for x in f]
  142. f.close()
  143. s_genes = cell_cycle_genes[:43]
  144. g2m_genes = cell_cycle_genes[43:]
  145. cell_cycle_genes = [x for x in cell_cycle_genes if x in adata.var_names]
  146. sc.tl.score_genes_cell_cycle(adata, s_genes=s_genes, g2m_genes=g2m_genes)
  147. phase_order = {'G1': 1, 'S': 2, 'G2M': 3}
  148. # phase_order = {"G1": 1, "S": 3, "G2M": 2}
  149. adata.obs['phase_ordinal'] = adata.obs['phase'].map(phase_order)
  151. psuper = Psupertime()
  152. # Fit the model
  153. psuper.run(adata, 'phase_ordinal')
  154. # psuper.plot_labels_over_psupertime(adata, "phase_ordinal")
  155. psuper.predict_psuper(adata)
  156. if save_name is not None:
  157. adata.write_h5ad(save_name)
  158. print("Computing gene expression along pseudotime...")
  159. # Do windowing
  160. if window is None:
  161. if window_params is None:
  162. window_params = {"n_windows": 30, "sigma": 0.03, "max_distance": 0.1}
  163. window = scTransient.windowing.ConfinedGaussianWindow(**window_params)
  164. n_windows = window.n_windows
  165. qmin = adata.obs['psupertime'].quantile(exclude_pt_ends[0])
  166. qmax = adata.obs['psupertime'].quantile(exclude_pt_ends[1])
  167. adata = adata[(adata.obs["psupertime"] > qmin) & (adata.obs["psupertime"] < qmax), :].copy()
  168. if trajectory is None: # take all
  169. node_col = "phase"
  170. path = list(np.unique(adata.obs[node_col]))
  171. pseudotime_signals_array = window_trajectory(adata,
  172. trajectory=path,
  173. node_col=node_col,
  174. window=window,
  175. pseudotime_col='psupertime',
  176. exclude_minimum=False)
  177. pseudotime_signals_dict = {}
  178. for idx, g in enumerate(adata.var_names):
  179. pseudotime_signals_dict[g] = pseudotime_signals_array[:, idx]
  180. wt = WaveletTransform(scales=np.arange(1, 5), wavelet="mexh")
  181. waves, scores = get_scored_wavelet_across_sigs(pseudotime_signals_dict,
  182. wt,
  183. modified_z_score_with_scaletime,
  184. score_threshold=scoring_threshold,
  185. normalize_signal=False)
  186. return waves, scores, pseudotime_signals_dict, adata, psuper
  188. # %%
  191. # %%
  192. thresh = 4
  193. window_params = {"n_windows": 30, "sigma": 0.03, "max_distance": 0.11}
  195. wr, scoresr, psdr, adata, psuper = pipeline_astral_cellcycle(load_astral,
  196. window_params=window_params,
  197. scoring_threshold=thresh,
  198. coverage_threshold=0.0,
  199. save_name=None,
  200. exclude_pt_ends=(0.1,0.9),
  201. repeat=True)
  203. # %%
  204. gene_df = adata.to_df()
  206. # %%
  207. wt = scTransient.wavelets.WaveletTransform(scales=np.arange(1, 5), wavelet="mexh")
  209. # %%
  210. tes, p, tes_all = scTransient.utils.permutation_dist(gene_df,
  211. adata.obs["psupertime"],
  212. wavelet_transform=wt,
  213. n_permutations=2)
  215. # %%
  218. # %%
  219. tes_np = np.array(tes_all)
  220. tes_vals = np.where(tes > 10)[0]
  221. tes_sig = np.where(p < 0.05)[0]
  223. # %%
  226. # %%
  227. olap = set(tes_vals).intersection(tes_sig)
  229. # %%
  232. # %%
  233. g = adata.var_names
  234. for i in tes_sig:
  235. print(g[i])
  237. # %%
  240. # %%
  241. # f = open("tes_all.pkl", "wb")
  242. # pkl.dump(tes_all, f)
  243. # f.close()
  245. # %%
  246. p_vals = np.zeros(adata.shape[1])
  247. for i in range(adata.shape[1]):
  248. p_vals[i] = np.sum(tes[i] < tes_np[:,i]) / tes_np.shape[0]
  251. # %%
  252. p_vals
  254. # %%
  257. # %%
  258. v, bins, _ = plt.hist(p_vals, bins=100, density=True);
  259. plt.xlabel("p-value")
  260. plt.ylabel("Prob dens.")
  261. plt.title("Distribution of p-values across gene TES")
  263. # %%
  264. sig = np.where(p_vals < 0.01)[0]
  266. # %%
  267. tes_max = tes.copy()
  268. ss = np.argsort(tes_max)
  270. # %%
  271. olap = set(sig).intersection(ss[-16:])
  273. # %%
  274. olap
  276. # %%
  277. num_bins = 20
  279. # Compute bin edges and assign bins
  280. adata.obs['psupertime_bin'], bin_edges = pd.qcut(adata.obs['psupertime'], q=num_bins, labels=False, retbins=True)
  282. # compute bin midpoints for correct x-axis scaling
  283. bin_midpoints = (bin_edges[:-1] + bin_edges[1:]) / 2
  284. phase_proportions = adata.obs.groupby(['psupertime_bin', 'phase']).size().unstack(fill_value=0)
  285. phase_proportions = phase_proportions.div(phase_proportions.sum(axis=1), axis=0)
  287. # for use in large figure at end of notebook
  288. fig9_x = bin_midpoints
  289. fig9_y = phase_proportions.T.values
  290. fig9_labels=phase_proportions.columns
  292. # Replot with original psupertime values on x-axis
  293. plt.figure(figsize=(8, 5))
  294. plt.stackplot(bin_midpoints, phase_proportions.T.values, labels=phase_proportions.columns, alpha=0.8)
  296. # Formatting
  297. plt.xlabel("Psupertime") # Change x-axis label
  298. plt.ylabel("Proportion of Cells")
  299. plt.title("Stacked Cell Cycle Phase Proportions Across Psupertime")
  300. plt.legend(title="Phase", bbox_to_anchor=(1.05, 1), loc='upper left')
  301. plt.grid(False)
  304. # %%
  305. phase_proportions
  307. # %%
  308. last_g1_idx = np.where(phase_proportions["G1"] <= 0.5)[0][0] # 5
  309. last_s_idx = np.where(phase_proportions["S"][last_g1_idx+1:] <= 0.5)[0][0] + last_g1_idx # 11
  310. last_g1_idx /= phase_proportions.shape[0] # get fraction along pt (this is bad variable naming, I know)
  311. last_s_idx /= phase_proportions.shape[0] # get fraction along pt
  312. pt_min = 0
  313. pt_max = 29
  314. last_g1 = (pt_max - pt_min) * last_g1_idx + pt_min
  315. last_s = (pt_max-pt_min) * last_s_idx + pt_min
  317. # %%
  318. adata.obs["phase"].value_counts()
  320. # %%
  321. thresh = 7
  322. g_above_thresh = [k for k, v in scoresr.items() if v > thresh]
  323. print(len(g_above_thresh))
  325. # %%
  326. thresh = 7
  327. g_above_thresh = [k for k, v in scoresr.items() if v > thresh]
  328. print(len(g_above_thresh))
  329. pt_above_thresh = []
  330. for g in g_above_thresh:
  331. pt_above_thresh.append(psdr[g])
  333. # %%
  334. all_scores = list(scoresr.values())
  335. plt.hist(all_scores, bins=500);
  336. plt.xlabel("Score")
  337. plt.ylabel("Frequency")
  338. plt.title("Score distribution for genes in cell cycle dataset")
  340. # %%
  341. import matplotlib.pyplot as plt
  342. from sklearn.cluster import KMeans
  343. from sklearn.metrics import silhouette_score
  344. import numpy as np
  345. from collections import defaultdict as dd
  346. kmeans = KMeans(n_clusters=5, random_state=0)
  347. labels = kmeans.fit_predict(pt_above_thresh)
  349. # %%
  350. c = dd(list)
  351. for idx_g, g in enumerate(g_above_thresh):
  352. c[labels[idx_g]].append(g)
  354. # %%
  355. for idx in range(5):
  356. fig, ax = plt.subplots()
  357. for g in c[idx]:
  358. ax.plot(psdr[g])
  359. ax.axvline(last_g1, linestyle="--")
  360. ax.axvline(last_s, linestyle="--")
  361. ax.set_title(f"Cluster {idx}")
  362. ax.set_xticks([5,15,25])
  363. ax.set_xticklabels(["G1", "S", "G2M"])
  364. fig.savefig(f"{r_dir}/cluster_{idx}.png")
  366. # %%
  367. # write out genes in each cluster
  368. # for idx in range(5):
  369. # f = open(f"{r_dir}/genes_group_{idx}.txt", "w")
  370. # for g in c[idx]:
  371. # f.write(f"{g}\n")
  372. # f.close()
  374. # %%
  375. ## For writing out all genes
  377. # f = open(f"{r_dir}/astral_genes.txt", "w")
  378. # for g in g_above_thresh:
  379. # print(g)
  380. # f.write(f"{g}\n")
  381. # f.close()
  383. # %%
  384. # Compute G1 and S to be in PT instead of by index
  386. last_g1_idx = np.where(phase_proportions["G1"] <= 0.5)[0][0] # 5
  387. last_s_idx = np.where(phase_proportions["S"][last_g1_idx+1:] <= 0.5)[0][0] + last_g1_idx # 11
  388. last_g1_idx /= phase_proportions.shape[0] # get fraction along pt
  389. last_s_idx /= phase_proportions.shape[0] # get fraction along pt
  390. pt_min = np.min(adata.obs["psupertime"])
  391. pt_max = np.max(adata.obs["psupertime"])
  392. last_g1_pt = (pt_max - pt_min) * last_g1_idx + pt_min
  393. last_s_pt = (pt_max-pt_min) * last_s_idx + pt_min
  395. # %%
  396. g = "AK6"
  397. x = np.linspace(np.min(adata.obs["psupertime"]), np.max(adata.obs["psupertime"]), len(psdr[g]))
  398. plt.plot(x, psdr[g])
  399. plt.plot(adata.obs["psupertime"], adata[:, "AK6"].X[:, 0], ".")
  400. plt.axvline(last_g1_pt, linestyle=":", label="Transition to S")
  401. plt.axvline(last_s_pt, linestyle="--", label="Transition to G2/M")
  402. plt.legend()
  403. plt.title(f"{g} expression along pseudotime")
  404. plt.xlabel("Pseudotime")
  405. plt.ylabel("Gene expression")
  406. plt.savefig(f"{r_dir}/{g}_expression.png")
  408. # %%
  409. g = "ATL2"
  410. x = np.linspace(np.min(adata.obs["psupertime"]), np.max(adata.obs["psupertime"]), len(psdr[g]))
  411. plt.plot(x, psdr[g])
  412. plt.plot(adata.obs["psupertime"], adata[:, g].X[:, 0], ".")
  413. plt.axvline((pt_max - pt_min)*5/20 + pt_min, linestyle=":", label="Transition to S")
  414. plt.axvline((pt_max-pt_min)*11/20 + pt_min, linestyle="--", label="Transition to G2/M")
  415. plt.legend()
  416. plt.title(f"{g} expression along pseudotime")
  417. plt.xlabel("Pseudotime")
  418. plt.ylabel("Gene expression")
  419. plt.savefig(f"{r_dir}/{g}_expression.png")
  421. # %% [markdown]
  422. # # Known cell cycle markers
  424. # %%
  425. f = open('regev_lab_cell_cycle_genes.txt', "r")
  426. cell_cycle_genes = [x.strip() for x in f]
  427. f.close()
  428. s_genes = cell_cycle_genes[:43]
  429. g2m_genes = cell_cycle_genes[43:]
  430. cell_cycle_genes = [x for x in cell_cycle_genes if x in adata.var_names]
  432. # %%
  435. # %%
  436. # For some reason, some of the adata.var_names can be NaN
  437. idx_list = []
  438. for idx, v in enumerate(adata.var_names):
  439. if isinstance(v, float):
  440. idx_list.append(idx)
  441. if len(idx_list) > 0:
  442. buf = list(adata.var_names)
  443. for idx in idx_list:
  444. buf[idx] = ""
  445. adata.var_names = buf
  447. # %%
  448. # which S genes are in our data?
  449. s_in_data = set([s.lower() for s in s_genes]).intersection(set([v.lower() for v in adata.var_names]))
  450. s_in_data = [s.upper() for s in s_in_data]
  451. s_in_data.sort()
  453. # which g2 genes are in our data?
  454. g2_in_data = set([s.lower() for s in g2m_genes]).intersection(set([v.lower() for v in adata.var_names]))
  455. g2_in_data = [s.upper() for s in g2_in_data]
  456. g2_in_data.sort()
  458. # %%
  459. print(f"Number of S-related genes in the dataset: {len(s_in_data)}")
  461. # %%
  462. print(f"Number of G2-related genes in the dataset: {len(g2_in_data)}")
  464. # %%
  465. fig, axs = plt.subplots(8,3)
  466. fig.set_figheight(12)
  467. fig.set_figwidth(8)
  468. for idx, g in enumerate(s_in_data):
  469. i, j = np.unravel_index(idx, axs.shape)
  470. ax = axs[i,j]
  471. x = np.linspace(np.min(adata.obs["psupertime"]), np.max(adata.obs["psupertime"]), len(psdr[g]))
  472. ax.plot(x, psdr[g], label="Windowed signal")
  473. ax.plot(adata.obs["psupertime"], adata[:, g].X[:, 0], ".", label="Cell data")
  474. ax.axvline((pt_max - pt_min)*5/20 + pt_min, linestyle=":", label="Transition to S")
  475. ax.axvline((pt_max-pt_min)*11/20 + pt_min, linestyle="--", label="Transition to G2/M")
  476. # ax.legend()
  477. ax.set_title(f"{g}")
  478. # ax.set_xlabel("Pseudotime")
  479. # ax.set_ylabel("Gene expression")
  480. if idx == 11:
  481. ax.legend(bbox_to_anchor=(1,1))
  482. fig.tight_layout(rect=[0, 0.03, 1, 0.95])
  483. fig.suptitle("S genes along pseudotime")
  485. # plt.savefig(f"{r_dir}/s_gene_expression.png")
  487. # %%
  488. num_plots = len(g2_in_data)
  489. num_columns = 3
  490. num_rows = num_plots // num_columns
  491. if num_plots % num_columns != 0:
  492. num_rows += 1
  495. fig, axs = plt.subplots(num_rows, num_columns)
  496. fig.set_figheight(4/3*num_rows)
  497. fig.set_figwidth(8)
  498. for idx, g in enumerate(g2_in_data):
  499. i, j = np.unravel_index(idx, axs.shape)
  500. ax = axs[i,j]
  501. x = np.linspace(np.min(adata.obs["psupertime"]), np.max(adata.obs["psupertime"]), len(psdr[g]))
  502. ax.plot(x, psdr[g], label="Windowed signal")
  503. ax.plot(adata.obs["psupertime"], adata[:, g].X[:, 0], ".", label="Cell data")
  504. ax.axvline((pt_max - pt_min)*5/20 + pt_min, linestyle=":", label="Transition to S")
  505. ax.axvline((pt_max-pt_min)*11/20 + pt_min, linestyle="--", label="Transition to G2/M")
  506. # ax.legend()
  507. ax.set_title(f"{g}")
  508. # ax.set_xlabel("Pseudotime")
  509. # ax.set_ylabel("Gene expression")
  510. if idx == 11:
  511. ax.legend(bbox_to_anchor=(1,1))
  512. fig.tight_layout(rect=[0, 0.03, 1, 0.95])
  513. fig.suptitle("G2M genes along pseudotime")
  515. # plt.savefig(f"{r_dir}/g2m_gene_expression.png")
  517. # %%
  518. from gprofiler import GProfiler
  519. for idx in range(4):
  520. gp = GProfiler(return_dataframe=True)
  521. results = gp.profile(organism="hsapiens", query=c[idx], sources=['GO:BP', 'GO:MF', 'GO:CC'])
  522. results.sort_values(by="p_value", ascending=True)
  523. sig_res = results[results["p_value"] < 0.05]
  524. break
  525. sig_res[["source", "native", "name", "p_value", "intersection_size"]].to_csv(f"{r_dir}/astral_enrichment_cluster{idx}.csv")
  527. # %%
  528. def plot_df(df: pd.DataFrame, title: str = None, save=None, ax=None, pmin=None, pmax=None, sources=None, annotated_names: list[str] = None
  529. ) -> None:
  530. """
  531. Plots each row of the DataFrame as a circle grouped by the 'source' column.
  532. The horizontal axis displays -log10(p_value) and the vertical positions
  533. are arranged based on the source group with added jitter.
  535. A legend is added for both the source groups and the circle size scale (intersection_size).
  537. Parameters:
  538. df (pd.DataFrame): A DataFrame containing the columns:
  539. - 'source': categorical column with 3 categories.
  540. - 'p_value': continuous values.
  541. - 'intersection_size': integers (will be used to scale circle sizes).
  542. - 'name': a descriptor for the row (unused in the plot).
  543. """
  544. # Compute the horizontal position: -log10(p_value)
  545. # (Make sure there are no p_value values equal to 0)
  546. df = df.copy() # Avoid modifying the original DataFrame
  547. fontsize=16
  548. if ax is None:
  549. fig, ax = plt.subplots()
  551. if (df["p_value"] <= 0).any():
  552. raise ValueError("All p_value entries must be positive so that -log10 can be computed.")
  554. df["neg_log10"] = -np.log10(df["p_value"])
  556. # Create a mapping for each unique source to a base y-position.
  557. if sources is None:
  558. unique_sources = sorted(df["source"].unique())
  559. else:
  560. unique_sources = sorted(np.unique(sources))
  561. source_to_index = {source: idx for idx, source in enumerate(unique_sources, start=1)}
  563. # Map sources to base y positions.
  564. df["base_y"] = df["source"].map(source_to_index)
  566. # Add vertical jitter to separate the circles
  567. np.random.seed(0) # For reproducibility
  568. jitter = np.random.uniform(-0.2, 0.2, size=len(df))
  569. df["y_pos"] = df["base_y"] + jitter
  571. # Create the plot
  573. # Plot each group with its own color and label.
  574. for source in unique_sources:
  575. subset = df[df["source"] == source]
  576. ax.scatter(
  577. subset["neg_log10"],
  578. subset["y_pos"],
  579. s=subset["intersection_size"] * 10, # Scale circle sizes; adjust factor as needed.
  580. alpha=0.7,
  581. label=source, # This will be used in the legend for sources.
  582. edgecolors="w"
  583. )
  585. ax.set_xlabel("-log10(p_value)", fontsize=fontsize)
  586. ax.set_yticks(list(source_to_index.values()), list(source_to_index.keys()), fontsize=fontsize)
  587. ax.set_ylim([0,4])
  588. # plt.ylabel("Source Group")
  589. if title is None:
  590. ax.set_title("Function Enrichment Analysis", fontsize=fontsize)
  591. else:
  592. ax.set_title(title, fontsize=fontsize)
  594. # First, add the legend for the source groups.
  595. # source_legend = plt.legend(title="Source", loc="upper right")
  596. # plt.gca().add_artist(source_legend)
  598. # Now, create a legend for the circle sizes corresponding to 'intersection_size'.
  599. # Use three representative sizes: min, median, and max.
  600. size_min = df["intersection_size"].min()
  601. # size_median = int(df["intersection_size"].median())
  603. size_max = df["intersection_size"].max()
  604. size_median = int((size_min + size_max)/2) #int(df["intersection_size"].median())
  605. size_scale = 10 # This is the factor applied to intersection_size for the marker size
  607. sizes = [size_min, size_median, size_max]
  608. markers = [
  609. ax.scatter([], [], s=size * size_scale, color="gray", alpha=0.7, edgecolors="w")
  610. for size in sizes
  611. ]
  612. labels = [f"{size}" for size in sizes]
  614. if annotated_names:
  615. # You could adjust the base offsets for arrow text.
  616. offset_x = 0.5
  617. offset_y = 0.5
  618. for i, row in df.iterrows():
  619. if row["name"] in annotated_names:
  620. x_point = row["neg_log10"]
  621. y_point = row["y_pos"]
  622. x_text = x_point + offset_x
  623. y_text = y_point + offset_y
  624. ax.annotate(
  625. row["name"],
  626. xy=(x_point, y_point),
  627. xytext=(x_text, y_text),
  628. arrowprops=dict(facecolor="black", arrowstyle="->"),
  629. fontsize=10,
  630. bbox=dict(boxstyle="round,pad=0.3", fc="yellow", alpha=0.5)
  631. )
  633. ax.legend(markers, labels, title="Intersection Size", bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0)
  634. ax.grid()
  635. if pmin is not None and pmax is not None:
  636. ax.set_xlim([pmin, pmax])
  637. plt.tight_layout()
  638. if save is not None:
  639. plt.savefig(save)
  642. # %%
  643. results = []
  644. sources=['GO:BP', 'GO:MF', 'GO:CC']
  645. for idx in range(5):
  646. gp = GProfiler(return_dataframe=True)
  647. results.append(gp.profile(organism="hsapiens", query=c[idx], sources=sources))
  648. results[-1].sort_values(by="p_value", ascending=True)
  649. sig_res = results[-1][results[-1]["p_value"] < 0.05]
  650. # break
  651. if sig_res.shape[0] == 0:
  652. continue
  653. sig_res[["source", "native", "name", "p_value", "intersection_size"]].to_csv(f"paper_figures/astral_enrichment_cluster{idx}.csv")
  655. # %%
  658. # %%
  659. fig, axs = plt.subplots(3)
  660. fig.set_figheight(8)
  661. fig_idx = 0
  662. fontsize=16
  663. p_min = np.inf
  664. p_max = -np.inf
  665. annot_lists = []
  666. annot_lists.append(["fatty acid catabolic process", "phagocytic vesicle membrane"])
  667. annot_lists.append(["DNA replication", "nuclear chromosome"])
  668. annot_lists.append(["N-acylsphingosine amidohydrolase activity", "tertiary granule lumen"])
  669. for r2 in results:
  670. r = r2[r2["p_value"] < 0.05]
  671. if r.shape[0] == 0:
  672. continue
  673. mmin = np.min(r["p_value"])
  674. mmax = np.max(r["p_value"])
  675. p_min = np.min([mmin, p_min])
  676. p_max = np.max([mmax, p_max])
  677. p_min *= 0.8
  678. p_max *= 1.3
  679. for idx in range(3):
  680. # gp = GProfiler(return_dataframe=True)
  681. # results = gp.profile(organism="hsapiens", query=c[idx], sources=['GO:BP', 'GO:MF', 'GO:CC'])
  682. # results.sort_values(by="p_value", ascending=True)
  683. sig_res = results[idx][results[idx]["p_value"] < 0.05]
  684. # break
  685. if sig_res.shape[0] == 0:
  686. continue
  687. # sig_res[["source", "native", "name", "p_value", "intersection_size"]].to_csv(f"paper_figures/astral_enrichment_cluster{idx}.csv")
  688. plot_df(sig_res, title=f"Enrichment for Cluster {idx}", ax=axs[fig_idx], pmin = -np.log10(p_max), pmax=-np.log10(p_min), sources=sources, annotated_names=annot_lists[idx])
  689. # break
  690. fig_idx += 1
  691. # print(results)
  692. plt.savefig(f"{r_dir}/fig9_cellcycle_enrichment.png")
  693. plt.savefig(f"{r_dir}/fig9_cellcycle_enrichment.svg")
  695. # %% [markdown]
  696. # # Figure assembly
  698. # %%
  699. import matplotlib.gridspec as gridspec
  700. from string import ascii_uppercase
  702. # %%
  703. adata
  705. # %%
  706. sc.tl.umap(adata)
  707. sc.pl.umap(adata)
  709. # %%
  710. from collections import defaultdict as dd
  711. adata_pscs = sc.read_h5ad("pscs_cellcycle.h5ad")
  712. cluster_genes = {}
  713. pt_signals = dd(list)
  714. var_list = list(adata_pscs.var_names)
  715. for idx in range(4):
  716. cluster_genes[idx] = list(adata_pscs.uns["te_cluster"].loc[(adata_pscs.uns["te_cluster"] == idx).values].index)
  717. print(len(cluster_genes[idx]))
  718. for g in cluster_genes[idx]:
  719. g_idx = var_list.index(g)
  720. pt_signals[idx].append(adata_pscs.uns["pseudotime_signals"][:, g_idx])
  721. sc.tl.umap(adata_pscs)
  722. sc.pl.umap(adata_pscs)
  724. # %%
  725. fig = plt.figure(figsize=(10, 12))
  726. gs = gridspec.GridSpec(4, 2, figure=fig)
  727. fontsize=16
  729. ax = fig.add_subplot(gs[1,1])
  730. psupertime_figure = psuper.plot_identified_gene_coefficients(adata, n_top=10, ax=ax)
  731. ax.set_title("Genes for psupertime", fontsize=fontsize)
  732. ax.text(0.05, 0.15, ascii_uppercase[3], transform=ax.transAxes,
  733. fontsize=16, fontweight='bold', va='top', ha='left')
  737. ax = fig.add_subplot(gs[2, :])
  739. # Replot with original psupertime values on x-axis
  740. ax.stackplot(bin_midpoints, phase_proportions.T.values, labels=phase_proportions.columns, alpha=0.8)
  742. # Formatting
  743. ax.set_xlabel("Pseudotime", fontsize=fontsize) # Change x-axis label
  744. ax.set_ylabel("Proportion of Cells", fontsize=fontsize)
  745. ax.set_title("Cell Cycle Phase Proportions Across Pseudotime", fontsize=fontsize)
  746. ax.legend(title="Phase", loc='upper right')
  747. ax.grid(False)
  748. ax.set_xlim(bin_midpoints[0], bin_midpoints[-1])
  749. # Remove all margins from both axes.
  750. ax.margins(x=0, y=0)
  751. # Adjust subplot parameters to use all the figure area.
  752. plt.subplots_adjust(left=0, right=1, top=1, bottom=0)
  753. ax.text(0.025, 0.95, ascii_uppercase[4], transform=ax.transAxes,
  754. fontsize=16, fontweight='bold', va='top', ha='left')
  756. for idx in [1,3]:
  757. if idx == 1:
  758. plot_idx = 0
  759. else:
  760. plot_idx = 1
  761. ax = fig.add_subplot(gs[3, plot_idx])
  762. for ii in range(len(pt_signals[idx])):
  763. ax.plot(pt_signals[idx][ii])
  764. ax.axvline(last_g1, linestyle="--")
  765. ax.axvline(last_s, linestyle="--")
  766. ax.set_title(f"Cluster {idx}", fontsize=fontsize)
  767. g1_tick = last_g1/2
  768. s_tick = (last_s + last_g1)/2
  769. g2_tick = (len(psdr[g]) + last_s)/2
  770. ax.set_xticks([g1_tick, s_tick, g2_tick])
  771. ax.set_xticklabels(["G1", "S", "G2M"], fontsize=fontsize-2)
  772. ax.set_xlabel("Pseudotime", fontsize=fontsize)
  773. ax.text(0.05, 0.95, ascii_uppercase[plot_idx+5], transform=ax.transAxes,
  774. fontsize=16, fontweight='bold', va='top', ha='left')
  777. ax_sc = fig.add_subplot(gs[0,0])
  778. sc.pl.umap(adata, color=["leiden"], ax=ax_sc, show=False, s=800)
  779. ax_sc.set_title("Leiden clusters", fontsize=fontsize)
  780. ax_sc.text(0.05, 0.95, ascii_uppercase[0], transform=ax_sc.transAxes,
  781. fontsize=16, fontweight='bold', va='top', ha='left')
  783. ax_sc = fig.add_subplot(gs[1,0])
  784. sc.pl.umap(adata, color=["phase"], ax=ax_sc, show=False, s=800)
  785. ax_sc.set_title("Cell cycle phase", fontsize=fontsize)
  786. ax_sc.text(0.05, 0.95, ascii_uppercase[2], transform=ax_sc.transAxes,
  787. fontsize=16, fontweight='bold', va='top', ha='left')
  790. ax_sc = fig.add_subplot(gs[0,1])
  791. sc.pl.umap(adata, color=["n_genes"], ax=ax_sc, show=False, s=800)
  792. ax_sc.text(0.05, 0.95, ascii_uppercase[1], transform=ax_sc.transAxes,
  793. fontsize=16, fontweight='bold', va='top', ha='left')
  795. fig.tight_layout()
  796. plt.savefig(f"{r_dir}/fig7.png")
  797. plt.savefig(f"{r_dir}/fig7.svg")
  798. plt.savefig(f"{r_dir}/fig7.eps")
  800. # %%
  801. fig, axs = plt.subplots(1,2)
  802. fig.set_figheight(4)
  803. fig.set_figwidth(8)
  804. mmin = np.min(adata.obs["psupertime"])
  805. mmax = np.max(adata.obs["psupertime"])
  806. pt = np.linspace(mmin, mmax, len(psdr["PCNA"]))
  807. last_g1_pt = (mmax-mmin)*last_g1/30 + mmin
  808. last_s_pt = (mmax-mmin)*last_s/30 + mmin
  809. for idx, g in enumerate(["PCNA", "UNG"]):
  810. ax = axs[np.unravel_index(idx, axs.shape)]
  811. ax.plot(pt, psdr[g])
  812. ax.plot(adata.obs["psupertime"], adata[:, g].X[:,0], ".")
  813. ax.axvline(last_g1_pt, linestyle="--")
  814. ax.axvline(last_s_pt, linestyle="--")
  815. ax.set_title(f"{g}")
  816. # ax.set_xlabel("Pseudotime")
  817. g1_tick = (mmin+last_g1_pt)/2
  818. s_tick = (last_s_pt + last_g1_pt)/2
  819. g2_tick = (mmax + last_s_pt)/2
  820. # ax.set_xticks([5,12,25])
  821. ax.set_xticks([g1_tick, s_tick, g2_tick])
  822. ax.set_xticklabels(["G1", "S", "G2M"])
  823. if idx == 0:
  824. ax.set_ylabel("Protein Quant.")
  825. # ax.set_title(f"{g} - {adata[:, g].var['coverage'][g]}")
  826. fig.tight_layout()
  827. # fig.savefig(f"{r_dir}/pcna_ung_pseudotimecourses.png")
  828. # fig.savefig(f"{r_dir}/pcna_ung_pseudotimecourses.svg")
  830. # %% [markdown]
  831. # ### Cell cycle genes
  832. #
  833. # Since we are using supervised pseudotime to determine cell cycle phase, it is possible that the clusters we are identifying are simply groups of those same genes. This section clusters the pseudotimecourses of those genes and shows that they do not exhibit the same behavior as those identified by scTransient.
  835. # %%
  836. from sklearn.cluster import KMeans
  838. # %%
  839. cell_cycle_genes_in_data = set(cell_cycle_genes).intersection(set(adata.var_names))
  840. cell_cycle_genes_in_data = list(cell_cycle_genes_in_data)
  842. # %%
  843. psdr_mat = np.zeros((len(cell_cycle_genes_in_data), len(psdr["UNG"])))
  844. regev_gene_to_idx = {}
  845. idx_to_regev_gene = {}
  846. for idx, g in enumerate(cell_cycle_genes_in_data):
  847. psdr_mat[idx, :] = psdr[g]
  848. regev_gene_to_idx[g] = idx
  849. idx_to_regev_gene[idx] = g
  851. # %%
  852. k=5
  853. km = KMeans(n_clusters=k, random_state=42, n_init=10)
  854. clusters = km.fit_predict(psdr_mat)
  857. # %%
  858. genes_per_cluster = dd(list)
  859. pt_range = np.linspace(mmin, mmax, len(psdr["UNG"]))
  860. fig, axs = plt.subplots(3,2)
  861. for idx in range(5):
  862. ax = axs[np.unravel_index(idx, axs.shape)]
  863. for gidx, c in enumerate(clusters):
  864. if c == idx:
  865. ax.plot(pt_range, psdr_mat[gidx, :])
  866. genes_per_cluster[idx].append(cell_cycle_genes_in_data[gidx])
  867. ax.set_title(f"Cluster {idx}")
  868. ax.axvline(last_g1_pt, linestyle="--")
  869. ax.axvline(last_s_pt, linestyle="--")
  870. g1_tick = (mmin+last_g1_pt)/2
  871. s_tick = (last_s_pt + last_g1_pt)/2
  872. g2_tick = (mmax + last_s_pt)/2
  873. ax.set_xticks([g1_tick, s_tick, g2_tick])
  874. ax.set_xticklabels(["G1", "S", "G2M"])
  875. fig.tight_layout()
  876. fig.delaxes(axs[2,1])
  877. # plt.savefig(f"{r_dir}/clustered_cell_cycle_genes.png")
  878. # plt.savefig(f"{r_dir}/clustered_cell_cycle_genes.svg")

cellcycle.ipynb at commit 92b95ae, no license · at the source

Overview

Authors: Alexandre Hutton1, Jesús Muñoz-Estrada1, Jesse G Meyer1
ORCID iDs: Alexandre Hutton, Jesús Muñoz-Estrada, Jesse G Meyer
  1. Department of Computational Biomedicine, Board of Governors Innovation Center, Cedars Sinai Medical Center, Los Angeles CA 90048, United States
Institutions: Cedars-Sinai Medical Center (United States)
Journal: Nucleic acids research, volume 54, issue 8, article gkag368
Dates: received 8 May 2025; accepted 20 March 2026; published online 25 April 2026; in print April 2026
Type: Research article · Language: English
License: CC BY-NC
Identifiers: DOI 10.1093/nar/gkag368 · PMID 42033223 · PMCID PMC13109726 · OpenAlex W4410336708
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.1101/2025.05.07.652753
Status: code verified
Categories: genetics / omics (modality), human (organism), cellular / molecular (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Spectral & time-frequency, Physiology & signal measures
MeSH: Gene Expression Profiling*, Single-Cell Analysis*, Algorithms, Animals, Cell Cycle, Humans, Neurogenesis, Neurons, Single-Cell Gene Expression Analysis, Wavelet Analysis (* major topic)
Topic: Gene Regulatory Network Analysis (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Institute of General Medical Sciences (R35GM142502); Cedars-Sinai Medical Center
Citations: cited by 1 paper (Europe PMC); 58 references in the paper

Abstract

Transient changes in gene or protein expression often mark the key regulatory checkpoints that propel cells from one functional state to the next, yet they are easy to miss in sparse, noisy single-cell omics data. We introduce scTransient, which transforms single-cell expression profiles into continuous pseudotime signals and uses wavelet-based signal processing to isolate short-lived but biologically meaningful bursts of gene activity. After ordering cells with supervised pseudotime, scTransient windows expression values with supervised pseudotime, applies a continuous wavelet transform, and assigns every gene a transient-event score (TES) that rewards sharp, isolated coefficients while penalizing background fluctuations. Synthetic benchmarks demonstrate that TES robustly recovers transient events (TE) across a wide range of parameters, including cell numbers, signal-to-noise ratios, and event widths. Applying scTransient to two real datasets—induced neuron development and single-cell cell cycle—demonstrates scTransient’s ability to detect TEs along pseudotime and identify proteins known to be related to the biological process under study. These include stem cell regulators in induced neuronal development and S-phase DNA replication factors in A549 cells. By extending trajectory inference from descriptive ordering to quantitative detection of fleeting regulatory programs, scTransient offers a practical route to uncover transient molecular events that drive development, differentiation, and disease.

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

Repository

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

xomicsdatascience/scTransient_notebooks

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 92b95ae198e621a450e4acec48aaf2171d37f570, 6 February 2026
Languages: Jupyter (3), Python (3), Shell (1)
Size: 16 files, 7 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, environment (requirements.txt), 3 notebooks
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (6 files), Matplotlib (4 files), anndata (3 files), pandas (3 files), scikit-learn (2 files), PyWavelets (1 file), rpy2 (1 file), Scanpy (1 file), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
8 files
At the source: github.com/xomicsdatascience/scTransient_notebooks

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

Datasets were downloaded from external sources: the cell cycle dataset [46] is available through the ProteomeXchange Consortium [20] via PRIDE [21] with ID PXD049412. The iNeuron raw and processed data is available on massive under ID MSV000100760 with DOI: https://doi.org/doi:10.25345/C5FQ9QK2G. The synthetic data generation code is available from: https://github.com/xomicsdatascience/scTransient_notebooks.

The scTransient code is available from Zenodo and the PSCS [19] interface includes scTransient analysis capabilities. The notebooks for data analysis to produce the figures in this paper are on Zenodo.

Reproduced under the paper's license (CC BY-NC), 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, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 10 MeSH terms, 2 funders, 53 references.

Cite

This paper

Hutton, A., Muñoz-Estrada, J., & Meyer, J. G. (2026). Single-cell trajectory inference for detecting transient events in biological processes. Nucleic acids research, 54(8), gkag368. https://doi.org/10.1093/nar/gkag368

BibTeX

@article{hutton2026single,
author = {Hutton, Alexandre and Muñoz-Estrada, Jesús and Meyer, Jesse G},
title = {{Single-cell trajectory inference for detecting transient events in biological processes}},
journal = {Nucleic acids research},
year = {2026},
month = apr,
volume = {54},
number = {8},
pages = {gkag368},
publisher = {Oxford University Press},
issn = {0305-1048},
doi = {10.1093/nar/gkag368},
url = {https://doi.org/10.1093/nar/gkag368},
pmid = {42033223},
pmcid = {PMC13109726}
}

RIS

TY - JOUR
AU - Hutton, Alexandre
AU - Muñoz-Estrada, Jesús
AU - Meyer, Jesse G
TI - Single-cell trajectory inference for detecting transient events in biological processes
T2 - Nucleic acids research
J2 - Nucleic Acids Res
PY - 2026
DA - 2026/04/01
VL - 54
IS - 8
SP - gkag368
SN - 0305-1048
PB - Oxford University Press
DO - 10.1093/nar/gkag368
UR - https://doi.org/10.1093/nar/gkag368
LA - en
ER -

CSL-JSON

{
"id": "10.1093/nar/gkag368",
"type": "article-journal",
"title": "Single-cell trajectory inference for detecting transient events in biological processes",
"container-title": "Nucleic acids research",
"author": [
{
"family": "Hutton",
"given": "Alexandre"
},
{
"family": "Muñoz-Estrada",
"given": "Jesús"
},
{
"family": "Meyer",
"given": "Jesse G"
}
],
"container-title-short": "Nucleic Acids Res",
"volume": "54",
"issue": "8",
"page": "gkag368",
"DOI": "10.1093/nar/gkag368",
"PMID": "42033223",
"PMCID": "PMC13109726",
"ISSN": "0305-1048",
"publisher": "Oxford University Press",
"URL": "https://doi.org/10.1093/nar/gkag368",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
1
]
]
}
}

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.mcpro.2026.101604 [code]
Optimizing NGN2 Dosage Enhances the Neuronal Enrichment of iPSC-Derived Neuronal Cultures.
Journal: Molecular & cellular proteomics : MCP
In common: anndata, Scanpy, scikit-learn, 4 other tools, genetics / omics, cellular / molecular, 3 references, author Jesse G Meyer
[2] doi:10.21203/rs.3.rs-9676637/v1 [code]
A Comprehensive Benchmarking of Spatial Deconvolution and Domain Detection Methods across Diverse Tissues and Spatial Transcriptomic Technologies
Journal: Research Square (preprint)
In common: rpy2, anndata, Scanpy, 5 other tools, genetics / omics, 2 references
[3] 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: rpy2, anndata, Scanpy, 5 other tools, genetics / omics, cellular / molecular, 1 reference
[4] doi:10.1038/s41467-026-75722-1 [code]
Single-nucleus analysis of the adult human olfactory epithelium uncovers shared neurogenesis programs with the brain.
Journal: Nature communications
In common: anndata, Scanpy, scikit-learn, 4 other tools, genetics / omics, 3 references
[5] doi:10.1371/journal.pcbi.1014346 [code]
StPedf: Cell trajectory inference of spatial transcriptomics via spatial proximity embedding and spatial density-adaptive fusion.
Journal: PLoS computational biology
In common: rpy2, anndata, Scanpy, 5 other tools, genetics / omics, 1 reference
[6] doi:10.1093/bib/bbag298 [code]
Empowering multifaceted analysis of spatial transcriptomics data with RGAST.
Journal: Briefings in bioinformatics
In common: rpy2, anndata, Scanpy, 5 other tools, genetics / omics, 1 reference
[7] doi:10.1016/j.stem.2026.05.005 [code]
Generation of human appetite-regulating neurons and tanycytes from pluripotent stem cells.
Journal: Cell stem cell
In common: rpy2, anndata, Scanpy, 5 other tools, cellular / molecular, 1 reference
[8] doi:10.1002/advs.77003 [code]
SemanticST: A Scalable Multi-Contextual Graph Learning Framework for Uncovering Spatial Niches and Robust Multi-Sample Integration in Spatial Transcriptomics.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: rpy2, anndata, Scanpy, 5 other tools, genetics / omics, 1 reference
[9] doi:10.3390/ijms27167275 [code]
Integrative Multi-Omics Analysis of Multiple Sclerosis Reveals Cell-Type-Specific Regulatory Landscapes and Discordant Methylation-Expression Coupling.
Journal: International journal of molecular sciences
In common: anndata, Scanpy, scikit-learn, 4 other tools, genetics / omics, cellular / molecular, 2 references
[10] doi:10.1016/j.xgen.2026.101217 [code]
ProtoCloud: A prototypical self-explaining model for single-cell analysis.
Journal: Cell genomics
In common: anndata, Scanpy, scikit-learn, 4 other tools, genetics / omics, cellular / molecular, 2 references

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.