OSCR

SemanticST: A Scalable Multi-Contextual Graph Learning Framework for Uncovering Spatial Niches and Robust Multi-Sample Integration in Spatial Transcriptomics.

Code ↔ Paper

9 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 9 matches
  1. [1] § Results › Overview of SemanticST ↔ semanticst/SemanticST_main.py, lines 28–110 · score 0.77 · min cut loss, reconstruction loss, learning embedding, learned semantic graphs, adjacency matrix, optimization
  2. [2] § Method › SemanticST › Semantic Graph Learning ↔ semanticst/model.py, lines 145–210 · score 0.70 · GCN layers, activation function, feature matrix, semantic graph, nodes, encoder
  3. [3] § Method › Mini‐Batch Training ↔ semanticst/loading_batches.py, lines 126–182 · score 0.68 · DataLoader, PyTorch, mini batch, shuffling, training, spots
  4. [4] § Method › Mini‐Batch Training ↔ semanticst/SemanticST_main.py, lines 28–110 · score 0.68 · DataLoader, spatial graph, adjacency matrix, iteration, reconstructed, PyTorch
  5. [5] § Method › SemanticST's Objective Function › Community‐Based Detection Loss Function ↔ semanticst/SemanticST_main.py, lines 264–334 · score 0.62 · min cut loss, learned embedding, optimize, semantic graphs, reconstruction, encoders
  6. [6] § Method › Data Preprocessing ↔ semanticst/preprocess.py, lines 131–147 · score 0.61 · variable genes, Scanpy, filtered, Preprocessing, Xenium, cells
  7. [7] § Method › SemanticST's Objective Function › Community‐Based Detection Loss Function ↔ semanticst/model.py, lines 75–122 · score 0.60 · Gumbel Softmax, mincut loss, Detection, embedding, matrix, graph
  8. [8] § Method › SemanticST ↔ semanticst/Semantic_graphs.py, lines 85–203 · score 0.56 · graph neural network, Semantic graph learning, GNN, loss
  9. [9] § Method › SemanticST › Fusion of the Latent Representations for Each Semantic Graph ↔ semanticst/model.py, lines 145–210 · score 0.55 · node feature matrix, encoding, fused, decoder, Fusion, encoder

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 · 451 lines · 18 KB · MIT · 3 matches

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. Created on Wed Mar 27 11:31:26 2024
  6. @author: Roxana
  7. """
  9. import numpy as np
  10. import scipy.sparse as sp
  11. import torch
  12. import torch.nn.functional as F
  13. from tqdm import tqdm
  15. from .preprocess import (
  16. preprocess,
  17. construct_interaction,
  18. construct_interaction_KNN,
  19. construct_interaction_KNN_edge_index,
  20. construct_sparse_graph,
  21. sparse_mx_to_torch_sparse_tensor,
  22. fix_seed,
  23. )
  24. from .model import Encoder, DeepMinCutModel
  25. from .Semantic_graphs import SemanticGraphLearning
  28. class Semantic_batches():
  29. """
  30. A class for learning semantic representations from spatial transcriptomics (ST) data
  31. using graph-based methods.
  33. This class constructs spatial graphs, applies deep learning-based feature extraction,
  34. and integrates reconstruction loss and MinCut loss to enhance the learned embeddings.
  36. Parameters
  37. ----------
  38. adata : anndata.AnnData
  39. AnnData object containing spatial transcriptomics data.
  41. train_loader : torch.utils.data.DataLoader
  42. DataLoader for training batches of spatial transcriptomics data.
  44. test_loader : torch.utils.data.DataLoader
  45. DataLoader for testing batches of spatial transcriptomics data.
  47. num_iter : int
  48. Number of iterations (batches) per epoch.
  50. config : object
  51. Configuration object containing device, data type, and other hyperparameters.
  53. learning_rate : float, optional, default=0.001
  54. Learning rate for optimizing the model.
  56. weight_decay : float, optional, default=0.00
  57. Regularization parameter controlling weight decay in the optimizer.
  59. epochs : int, optional, default=1
  60. Number of training epochs.
  62. dim_output : int, optional, default=64
  63. Dimensionality of the output embeddings.
  65. alpha : float, optional, default=1
  66. Weight factor controlling the influence of the reconstruction loss in representation learning.
  68. beta : float, optional, default=0.1
  69. Weight factor controlling the influence of the **MinCut loss** in representation learning.
  71. Integration : bool, optional, default=True
  72. Whether to integrate additional data sources in representation learning.
  74. Attributes
  75. ----------
  76. dim_input : int
  77. Dimensionality of the input features.
  79. device : str
  80. Computation device (`'cpu'` or `'cuda'`), retrieved from config.
  82. adj : torch.Tensor
  83. Adjacency matrix representing the spatial interactions between spots.
  85. edge_index : torch.Tensor
  86. Edge list representing graph connectivity.
  88. G : list
  89. List of semantic graphs constructed during training.
  91. emb_rec : np.ndarray
  92. Learned representations from the decoder.
  94. emb_h : np.ndarray
  95. Learned representations from the encoder.
  97. Methods
  98. -------
  99. train():
  100. Trains the semantic graph learning model on ST data using reconstruction loss and MinCut loss.
  102. test():
  103. Evaluates the trained model and extracts representations.
  105. Returns
  106. -------
  107. anndata.AnnData
  108. Updated AnnData object with learned embeddings stored in `adata.obsm['emb_decoder']`
  109. and `adata.obsm['emb_encoder']`.
  110. """
  112. def __init__(
  113. self,
  114. adata,
  115. train_loader,
  116. test_loader,
  117. num_iter,
  118. config,
  119. learning_rate=0.001,
  120. weight_decay=0.00,
  121. epochs=1000,
  122. dim_output=64,
  123. alpha=1,
  124. beta=0.1,
  125. Integration=True
  126. ):
  127. self.adata = adata
  128. self.train_loader = train_loader
  129. self.test_loader = test_loader
  130. self.config = config
  131. self.learning_rate = learning_rate
  132. self.weight_decay = weight_decay
  133. self.epochs = epochs
  134. self.datatype = self.config.dtype
  135. self.alpha = alpha
  136. self.beta = beta
  137. self.Integration = Integration
  138. self.device = self.config.device
  139. fix_seed(self.config.seed)
  140. batch, _ids = next(iter(train_loader))
  141. self.num_iter = num_iter
  142. self.dim_input = batch[:, :-2].shape[1]
  143. self.dim_output = dim_output
  144. print("\n🚀 Welcome to SemanticST! 🚀\n")
  145. print("📢 Recommendation: If your dataset contains more than 40000 spots or cells, we suggest using **mini-batch training** for efficiency.")
  147. def train(self):
  148. print("\n✅ Using Mini-Batch Training for better efficiency! 🏋️‍♂️")
  149. self.min_model = DeepMinCutModel()
  151. print('Begin to train ST data...')
  152. self.loss = 0
  153. total_loss = 0
  154. batch_idx = 0
  155. self.model = Encoder(self.dim_input, self.dim_output, num_graphs=4).to(self.device)
  156. self.optimizer = torch.optim.Adam(self.model.parameters(), self.learning_rate,
  157. weight_decay=self.weight_decay)
  159. for batch_idx, (data, ids) in enumerate(tqdm(self.train_loader, total=self.num_iter, desc="Training Progress")):
  160. spot_data = data.float()
  161. num_nodes = data.shape[0]
  162. coor = spot_data[:, -2:]
  163. coor = coor.to(torch.int)
  164. W = []
  165. self_loops = torch.arange(num_nodes, device=self.device)
  166. self_loops = torch.stack([self_loops, self_loops], dim=0)
  167. if self.datatype in ['Stereo', 'Slide']:
  168. self.adj = construct_sparse_graph(coor) # scipy sparse, stays sparse
  169. gn = self.adj + sp.eye(self.adj.shape[0])
  170. self.graph_neigh = sparse_mx_to_torch_sparse_tensor(gn).to(self.device) # binary mask
  171. self.edge_index = construct_interaction_KNN_edge_index(coor).to(self.device)
  172. else:
  173. self.adj, self.graph_neigh = construct_interaction(coor)
  174. self.graph_neigh = torch.FloatTensor(self.graph_neigh + np.eye(self.adj.shape[0])).to(self.device)
  175. self.adj = torch.FloatTensor(self.adj).to(self.device)
  176. self.edge_index = self.adj.nonzero().t()
  177. self.edge_index = torch.cat((self.edge_index, self_loops), dim=1)
  179. self.loop_weight = torch.full((num_nodes,), 0.1).to(self.device)
  180. self.sg_learning = SemanticGraphLearning(spot_data[:, :-2], self.adj, self.edge_index, self.device, self.config.use_mini_batch, self.datatype)
  181. self.G = self.sg_learning.train()
  183. for i in range(len(self.G)):
  184. if self.datatype in ['Stereo', 'Slide']:
  185. self.new_edge_weight = self.G[i]
  186. else:
  187. self.new_edge_weight = torch.cat((self.G[i], self.loop_weight))
  188. W.append(self.new_edge_weight)
  189. spot_data = torch.FloatTensor(spot_data[:, :-2])
  190. feature = spot_data.to(self.device)
  191. self.adj_weighted = self.edge_weights_to_sparse(num_nodes)
  193. for epoch in range(self.epochs):
  194. self.model.train()
  195. self.hiden_feat, self.emb, self.g, self.hidden_embeddings, self.attn_weights = self.model(feature, self.edge_index, self.graph_neigh, W)
  196. self.loss_feat = F.mse_loss(feature, self.emb)
  197. self.loss_deep_mincut = self.min_model.deep_mincut_loss(self.hiden_feat, self.adj_weighted)
  198. loss = self.alpha * self.loss_feat + self.beta * self.loss_deep_mincut
  199. self.optimizer.zero_grad()
  200. loss.backward()
  201. self.optimizer.step()
  202. total_loss += loss.data.item()
  204. batch_idx += 1
  205. self.loss = total_loss / (batch_idx + 1)
  207. del self.edge_index, self.adj, spot_data, self.graph_neigh, self.G
  208. del self.loop_weight, self.adj_weighted
  209. print("Optimization finished for ST data!")
  211. with torch.no_grad():
  212. self.model.eval()
  213. Emb_e = []
  214. Emb_d = []
  215. for batch_idx, (data, ids) in enumerate(tqdm(self.test_loader, desc="Testing Progress", unit="batch")):
  216. spot_data = data.float()
  217. num_nodes = data.shape[0]
  218. coor = spot_data[:, -2:]
  219. W = []
  220. self_loops = torch.arange(num_nodes, device=self.device)
  221. self_loops = torch.stack([self_loops, self_loops], dim=0)
  222. if self.datatype in ['Stereo', 'Slide']:
  223. self.adj, self.graph_neigh = construct_interaction_KNN(coor)
  224. self.graph_neigh = torch.FloatTensor(self.graph_neigh + np.eye(self.adj.shape[0])).to(self.device)
  225. self.edge_index = construct_interaction_KNN_edge_index(coor).to(self.device)
  226. self.adj = torch.FloatTensor(self.adj).to(self.device)
  227. else:
  228. self.adj, self.graph_neigh = construct_interaction(coor)
  229. self.graph_neigh = torch.FloatTensor(self.graph_neigh + np.eye(self.adj.shape[0])).to(self.device)
  230. self.adj = torch.FloatTensor(self.adj).to(self.device)
  231. self.edge_index = self.adj.nonzero().t()
  232. self.edge_index = torch.cat((self.edge_index, self_loops), dim=1)
  234. self.loop_weight = torch.full((num_nodes,), 0.1).to(self.device)
  235. self.sg_learning = SemanticGraphLearning(spot_data[:, :-2], self.adj, self.edge_index, self.device, self.config.use_mini_batch, self.datatype)
  236. self.G = self.sg_learning.evaluate(spot_data[:, :-2])
  237. for i in range(len(self.G)):
  238. if self.datatype in ['Stereo', 'Slide']:
  239. self.new_edge_weight = self.G[i]
  240. else:
  241. self.new_edge_weight = torch.cat((self.G[i], self.loop_weight))
  242. W.append(self.new_edge_weight)
  243. spot_data = torch.FloatTensor(spot_data[:, :-2])
  244. feature = spot_data.to(self.device)
  245. self.emb_rec = self.model(feature, self.edge_index, self.graph_neigh, W)[1].detach()
  246. self.emb_h = self.model(feature, self.edge_index, self.graph_neigh, W)[0].detach()
  247. Emb_d.append(self.emb_rec.cpu().numpy())
  248. Emb_e.append(self.emb_h.cpu().numpy())
  249. Emb_d = np.concatenate(Emb_d, axis=0)
  250. Emb_e = np.concatenate(Emb_e, axis=0)
  251. self.adata.obsm['emb_decoder'] = Emb_d
  252. self.adata.obsm['emb_encoder'] = Emb_e
  254. return self.adata
  256. def edge_weights_to_sparse(self, num_nodes):
  257. A = torch.sparse_coo_tensor(
  258. self.edge_index, self.new_edge_weight,
  259. (num_nodes, num_nodes), device=self.device,
  260. )
  261. return (A + A.t()).coalesce()
  264. class Semantic():
  265. """
  266. A class for training a semantic graph learning model on full spatial transcriptomics (ST) data
  267. without mini-batch training.
  269. This class constructs spatial graphs, applies deep learning-based feature extraction,
  270. and integrates reconstruction loss and MinCut loss to enhance the learned embeddings.
  272. Parameters
  273. ----------
  274. adata : anndata.AnnData
  275. AnnData object containing spatial transcriptomics data.
  277. config : object
  278. Configuration object containing device, data type, and other hyperparameters.
  280. learning_rate : float, optional, default=0.001
  281. Learning rate for optimizing the model.
  283. weight_decay : float, optional, default=0.00
  284. Regularization parameter controlling weight decay in the optimizer.
  286. epochs : int, optional, default=1000
  287. Number of training epochs.
  289. dim_input : int, optional, default=3000
  290. Dimensionality of the input features.
  292. dim_output : int, optional, default=64
  293. Dimensionality of the output embeddings.
  295. alpha : float, optional, default=10
  296. Weight factor controlling the influence of the reconstruction loss in representation learning.
  298. beta : float, optional, default=0.1
  299. Weight factor controlling the influence of the **MinCut loss** in representation learning.
  301. Integration : bool, optional, default=True
  302. Whether to integrate additional data sources in representation learning.
  304. Attributes
  305. ----------
  306. device : str
  307. Computation device (`'cpu'` or `'cuda'`), retrieved from config.
  309. adj : torch.Tensor
  310. Adjacency matrix representing the spatial interactions between spots.
  312. edge_index : torch.Tensor
  313. Edge list representing graph connectivity.
  315. G : list
  316. List of semantic graphs constructed during training.
  318. emb_rec : np.ndarray
  319. Learned representations from the decoder.
  321. emb_h : np.ndarray
  322. Learned representations from the encoder.
  324. Methods
  325. -------
  326. train():
  327. Trains the semantic graph learning model on the full dataset without mini-batching.
  329. Returns
  330. -------
  331. anndata.AnnData
  332. Updated AnnData object with learned embeddings stored in `adata.obsm['emb_decoder']`
  333. and `adata.obsm['emb_encoder']`.
  334. """
  336. def __init__(self,
  337. adata, config,
  338. learning_rate=0.001,
  339. weight_decay=0.00,
  340. epochs=1000,
  341. dim_input=3000,
  342. dim_output=64,
  343. alpha=10,
  344. beta=0.1,
  345. lambda_factor=0.1,
  346. Integration=True
  347. ):
  348. self.adata = adata.copy()
  349. self.config = config
  350. self.learning_rate = learning_rate
  351. self.weight_decay = weight_decay
  352. self.epochs = epochs
  353. self.random_seed = self.config.seed
  354. self.alpha = alpha
  355. self.beta = beta
  356. self.Integration = Integration
  357. self.datatype = self.config.dtype
  358. self.dim_input = dim_input
  359. self.dim_output = dim_output
  360. self.device = self.config.device
  361. self.lambda_factor = lambda_factor
  362. fix_seed(self.config.seed)
  363. print("\n🚀 Welcome to SemanticST! 🚀\n")
  364. print("📢 Recommendation: If your dataset contains more than 40000 spots or cells, we suggest using **mini-batch training** for efficiency.")
  366. def train(self):
  367. print("\n✅ Using Full Dataset Training (No Mini-Batching). 🔥")
  368. preprocess(self.adata, self.datatype)
  369. self.min_model = DeepMinCutModel()
  370. print('Begin to train ST data...')
  371. data = self.adata.obsm['feat'].copy()
  372. self.dim_input = data.shape[1]
  373. num_nodes = data.shape[0]
  374. coor = self.adata.obsm['spatial']
  375. coor = torch.from_numpy(coor).to(device=self.device, dtype=torch.int)
  376. W = []
  377. self_loops = torch.arange(num_nodes, device=self.device)
  378. self_loops = torch.stack([self_loops, self_loops], dim=0)
  379. if self.datatype in ['Stereo', 'Slide']:
  380. self.adj = construct_sparse_graph(coor) # scipy sparse, stays sparse
  381. gn = self.adj + sp.eye(self.adj.shape[0])
  382. self.graph_neigh = sparse_mx_to_torch_sparse_tensor(gn).to(self.device) # binary mask
  383. self.edge_index = construct_interaction_KNN_edge_index(coor).to(self.device)
  384. else:
  385. self.adj, self.graph_neigh = construct_interaction(coor)
  386. self.graph_neigh = torch.FloatTensor(self.graph_neigh + np.eye(self.adj.shape[0])).to(self.device)
  387. self.adj = torch.FloatTensor(self.adj).to(self.device)
  388. self.edge_index = self.adj.nonzero().t()
  389. self.edge_index = torch.cat((self.edge_index, self_loops), dim=1)
  391. self.loop_weight = torch.full((num_nodes,), 0.1).to(self.device)
  392. self.sg_learning = SemanticGraphLearning(data, self.adj, self.edge_index, self.device, self.config.use_mini_batch, self.datatype, lambda_factor=self.lambda_factor)
  393. self.sg_learning.train()
  394. self.G = self.sg_learning.evaluate(data)
  396. print("Semantic Graph Learning Completed")
  397. num_graphs = len(self.G[1])
  399. self.model = Encoder(self.dim_input, self.dim_output, num_graphs=num_graphs).to(self.device)
  400. self.optimizer = torch.optim.Adam(self.model.parameters(), self.learning_rate,
  401. weight_decay=self.weight_decay)
  403. for i in range(len(self.G)):
  404. if self.datatype in ['Stereo', 'Slide']:
  405. self.new_edge_weight = self.G[i]
  406. else:
  407. self.new_edge_weight = torch.cat((self.G[i], self.loop_weight))
  408. W.append(self.new_edge_weight)
  409. data = torch.FloatTensor(data)
  410. feature = data.to(self.device)
  411. self.adj_weighted = self.edge_weights_to_sparse(num_nodes)
  413. for epoch in tqdm(range(self.epochs), desc="Feature Learning Epochs"):
  414. self.model.train()
  415. self.hiden_feat, self.emb, self.g, self.hidden_embeddings, self.attn_weights = self.model(feature, self.edge_index, self.graph_neigh, W)
  416. self.loss_feat = F.mse_loss(feature, self.emb)
  417. self.loss_deep_mincut = self.min_model.deep_mincut_loss(self.hiden_feat, self.adj_weighted)
  418. loss = self.alpha * self.loss_feat + self.beta * self.loss_deep_mincut
  419. self.optimizer.zero_grad()
  420. loss.backward()
  421. self.optimizer.step()
  423. with torch.no_grad():
  424. self.model.eval()
  425. data = torch.FloatTensor(data)
  426. feature = data.to(self.device)
  427. self.emb_rec = self.model(feature, self.edge_index, self.graph_neigh, W)[1].detach()
  428. self.emb_h = self.model(feature, self.edge_index, self.graph_neigh, W)[0].detach()
  429. self.adata.obsm['emb_decoder'] = self.emb_rec.cpu().numpy()
  430. self.adata.obsm['emb_encoder'] = self.emb_h.cpu().numpy()
  431. return self.adata
  433. def edge_weights_to_sparse(self, num_nodes):
  434. A = torch.sparse_coo_tensor(
  435. self.edge_index, self.new_edge_weight,
  436. (num_nodes, num_nodes), device=self.device,
  437. )
  438. return (A + A.t()).coalesce()
  440. def cosine_similarity(self, pred_sp, emb_sp): # pred_sp: spot x gene; emb_sp: spot x gene
  441. """
  442. Calculate cosine similarity based on predicted and reconstructed gene expression matrix.
  443. """
  444. M = torch.matmul(pred_sp, emb_sp.T)
  445. Norm_c = torch.norm(pred_sp, p=2, dim=1)
  446. Norm_s = torch.norm(emb_sp, p=2, dim=1)
  447. Norm = torch.matmul(Norm_c.reshape((pred_sp.shape[0], 1)), Norm_s.reshape((emb_sp.shape[0], 1)).T) + -5e-12
  448. M = torch.div(M, Norm)
  449. if torch.any(torch.isnan(M)):
  450. M = torch.where(torch.isnan(M), torch.full_like(M, 0.4868), M)
  451. return M

SemanticST_main.py at commit ad3f204, under MIT · at the source

Overview

Authors: Roxana Zahedi1, Ahmadreza Argha2,3, Nona Farbehi2,3, Ivan Bakhshayeshi1, Thantrira Porntaveetus4,5, Youqiong Ye6, Nigel H Lovell2,3, Hamid Alinejad‐Rokny1,7
ORCID iDs: Roxana Zahedi, Ahmadreza Argha, Nona Farbehi, Ivan Bakhshayeshi, Youqiong Ye, Nigel H Lovell, Hamid Alinejad‐Rokny
  1. UNSW BioMedical Machine Learning Lab (BML), School of Biomedical Engineering, UNSW Sydney, Sydney, Australia
  2. School of Biomedical Engineering, UNSW Sydney, Sydney, Australia
  3. Tyree Institute of Health Engineering (IHealthE), UNSW Sydney, Sydney, Australia
  4. Center of Excellence in Precision Medicine and Digital Health, Department of Physiology, Faculty of Dentistry, Chulalongkorn University, Bangkok, Thailand
  5. Clinic of General, Special Care and Geriatric Dentistry, Center for Dental Medicine, University of Zurich, Zurich, Switzerland
  6. Center for Immune‐Related Diseases, Shanghai Institute of Immunology, Shanghai Jiao Tong University School of Medicine, Shanghai, China
  7. Visiting Scholar (Collaborative Projects), Center of Excellence in Precision Medicine and Digital Health, Chulalongkorn University, Bangkok, Thailand
Institutions: UNSW Sydney (Australia); Chulalongkorn University (Thailand); University of Zurich (Switzerland); Shanghai Jiao Tong University (China); Shanghai Institute of Immunology (China)
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany), article e77003
Dates: received 14 January 2026; accepted 27 July 2026; published online 31 August 2026; in print August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/advs.77003 · PMID 42671391 · PMCID PMC13528690 · OpenAlex W7204790580
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), methods / tools (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Connectivity, Machine learning, fMRI & imaging
Keywords: deep learning, graph neural network, semantic graph, spatial transcriptomics
Topic: Single-cell and spatial transcriptomics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Ratchadaphiseksomphot Endowment Fund, Chulalongkorn University (CTG168027); Health Systems Research Institute (69-145, 69-143); Thailand Science Research and Innovation Fund, Chulalongkorn University (HEA_FF_69_036_3200_003); UNSW (PS348543); UNSW Scientia Program Fellowship; Australian Research Council Discovery Early Career Researcher Award (DE220101210); NSW Cardiovascular Research Network Career Advancement (RG254353)
Citations: not cited yet (Europe PMC); 70 references in the paper

Abstract

Spatial transcriptomics (ST) analysis is often hindered by technical limitations and methodological biases that let dominant signals overshadow subtle but crucial biological patterns, such as rare cell types and fine‐grained heterogeneity. This is especially true for high‐complexity datasets from platforms like Xenium. We present SemanticST, a graph neural network (GNN) framework that addresses this challenge through a fundamentally different design. SemanticST is the first GNN method to implement mini‐batch training, enabling scalable analysis of massive ST datasets (validated on Xenium). Crucially, it employs a multi‐semantic graph fusion strategy that learns disentangled biological representations across tissue, using a min‐cut loss that requires neither graph corruption nor contrastive sampling. Benchmarking across diverse tissues (e.g., brain, embryo, tumor) confirms consistent superiority. It achieves up to 20% higher ARI/NMI on the gold‐standard brain cortex and uniquely delineates all mouse olfactory bulb layers and hippocampal sub‐regions. In high‐resolution breast cancer data, SemanticST identifies computationally plausible spatial domains, including a candidate rare triple receptor‐positive region and a FOXC2‐enriched EMT‐associated domain, from Xenium alone. Furthermore, SemanticST provides superior, robust multi‐sample integration on established benchmarks. SemanticST offers an essential, scalable framework for translating spatial complexity into biologically informative and testable hypotheses.

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

Repository

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

roxana9/SemanticST

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: ad3f2041f38927709f00df70bcda35ca19f08cf7, 7 September 2026
Languages: Python (23)
Size: 38 files, 23 scripts
Software Heritage: not archived
Found in: “Code Availability”
Holds: README, license file, environment (requirements.txt, setup.py)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (16 files), NumPy (12 files), Scanpy (11 files), Matplotlib (9 files), scikit-learn (9 files), pandas (8 files), PyTorch Geometric (7 files), rpy2 (6 files), SciPy (5 files), anndata (1 file), h5py (1 file), Numba (1 file), scikit-image (1 file), seaborn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
25 files
At the source: github.com/roxana9/SemanticST

Code Availability

The SemanticST algorithm is an open‐source Python implementation available at https://github.com/roxana9/SemanticST.

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

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

Datasets cited

Data Availability Statement

All data used in this study were obtained from previously published sources. A comprehensive list of these sources is provided in Table S3. For convenience, we have also made the compiled data available via Zenodo: https://zenodo.org/records/15339700.

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

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, pages, dates, 8 authors, 4 keywords, 7 funders, 61 references.

Cite

This paper

Zahedi, R., Argha, A., Farbehi, N., Bakhshayeshi, I., Porntaveetus, T., Ye, Y., Lovell, N. H., & Alinejad‐Rokny, H. (2026). SemanticST: A Scalable Multi-Contextual Graph Learning Framework for Uncovering Spatial Niches and Robust Multi-Sample Integration in Spatial Transcriptomics. Advanced science (Weinheim, Baden-Wurttemberg, Germany), e77003. https://doi.org/10.1002/advs.77003

BibTeX

@article{zahedi2026semanticst,
author = {Zahedi, Roxana and Argha, Ahmadreza and Farbehi, Nona and Bakhshayeshi, Ivan and Porntaveetus, Thantrira and Ye, Youqiong and Lovell, Nigel H and Alinejad‐Rokny, Hamid},
title = {{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)},
year = {2026},
month = aug,
pages = {e77003},
publisher = {Wiley},
issn = {2198-3844},
doi = {10.1002/advs.77003},
url = {https://doi.org/10.1002/advs.77003},
pmid = {42671391},
pmcid = {PMC13528690}
}

RIS

TY - JOUR
AU - Zahedi, Roxana
AU - Argha, Ahmadreza
AU - Farbehi, Nona
AU - Bakhshayeshi, Ivan
AU - Porntaveetus, Thantrira
AU - Ye, Youqiong
AU - Lovell, Nigel H
AU - Alinejad‐Rokny, Hamid
TI - SemanticST: A Scalable Multi-Contextual Graph Learning Framework for Uncovering Spatial Niches and Robust Multi-Sample Integration in Spatial Transcriptomics
T2 - Advanced science (Weinheim, Baden-Wurttemberg, Germany)
J2 - Adv Sci (Weinh)
PY - 2026
DA - 2026/08/31
SP - e77003
SN - 2198-3844
PB - Wiley
DO - 10.1002/advs.77003
UR - https://doi.org/10.1002/advs.77003
LA - en
ER -

CSL-JSON

{
"id": "10.1002/advs.77003",
"type": "article-journal",
"title": "SemanticST: A Scalable Multi-Contextual Graph Learning Framework for Uncovering Spatial Niches and Robust Multi-Sample Integration in Spatial Transcriptomics",
"container-title": "Advanced science (Weinheim, Baden-Wurttemberg, Germany)",
"author": [
{
"family": "Zahedi",
"given": "Roxana"
},
{
"family": "Argha",
"given": "Ahmadreza"
},
{
"family": "Farbehi",
"given": "Nona"
},
{
"family": "Bakhshayeshi",
"given": "Ivan"
},
{
"family": "Porntaveetus",
"given": "Thantrira"
},
{
"family": "Ye",
"given": "Youqiong"
},
{
"family": "Lovell",
"given": "Nigel H"
},
{
"family": "Alinejad‐Rokny",
"given": "Hamid"
}
],
"container-title-short": "Adv Sci (Weinh)",
"page": "e77003",
"DOI": "10.1002/advs.77003",
"PMID": "42671391",
"PMCID": "PMC13528690",
"ISSN": "2198-3844",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/advs.77003",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
31
]
]
}
}

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.1093/bioinformatics/btag540 [code]
Deciphering spatial heterogeneity by multimodal spatial transcriptomics modelling with SpatialModal.
Journal: Bioinformatics (Oxford, England)
In common: rpy2, PyTorch Geometric, anndata, 10 other tools, methods / tools, genetics / omics, 15 references
[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, PyTorch Geometric, anndata, 10 other tools, methods / tools, genetics / omics, 10 references
[3] doi:10.1093/bib/bbag298 [code]
Empowering multifaceted analysis of spatial transcriptomics data with RGAST.
Journal: Briefings in bioinformatics
In common: rpy2, PyTorch Geometric, anndata, 9 other tools, methods / tools, genetics / omics, 11 references
[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: rpy2, PyTorch Geometric, anndata, 8 other tools, methods / tools, genetics / omics, 12 references
[5] doi:10.1038/s41467-026-71759-4 [code]
CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning.
Journal: Nature communications
In common: PyTorch Geometric, anndata, Scanpy, 7 other tools, 10 references
[6] doi:10.1002/advs.75969 [code]
Accurately Deciphering Tissue Heterogeneity From Spatial Multi-Modal and Multi-Omics With STransformer.
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany)
In common: PyTorch Geometric, anndata, Scanpy, 6 other tools, genetics / omics, 8 references
[7] 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, 7 other tools, genetics / omics, 7 references
[8] doi:10.1093/bioinformatics/btag430 [code]
SPIDER: spatially integrated denoising via embedding regularization with single cell supervision.
Journal: Bioinformatics (Oxford, England)
In common: rpy2, PyTorch Geometric, anndata, 7 other tools, genetics / omics, 6 references
[9] doi:10.1016/j.isci.2026.117206 [code]
ReliST: A model-agnostic risk layer for spatial transcriptomics deconvolution.
Journal: iScience
In common: anndata, Scanpy, PyTorch, 6 other tools, genetics / omics, 8 references
[10] 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: PyTorch Geometric, anndata, Numba, 10 other tools, 3 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.