OSCR

CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning.

Code ↔ Paper

11 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 11 matches
  1. [1] § Methods › Spatial proximity graph construction ↔ cellniche/utils.py, lines 282–354 · score 0.81 · NearestNeighbors, multi slice, spatial graph, undirected, squidpy, COO
  2. [2] § Results › CellNiche integrates cross-platform spatial maps and constructs a unified virtual tissue atlas ↔ cellniche/__init__.py, lines 1–44 · score 0.76 · Seurat alignment score, silhouette width, batch mixing, entropy, iLISI, CellNiche
  3. [3] § Methods › Loss function ↔ cellniche/model.py, lines 8–101 · score 0.70 · learnable parameter, temperature parameter, node embeddings, module, matrix, batch
  4. [4] § Results › CellNiche integrates cross-platform spatial maps and constructs a unified virtual tissue atlas ↔ cellniche/utils.py, lines 768–829 · score 0.65 · Seurat alignment score, batch mixing, cross, CellNiche
  5. [5] § Methods › Evaluation ↔ cellniche/utils.py, lines 561–640 · score 0.65 · clustering evaluation metrics, silhouette score, AMI, ARI, Macro
  6. [6] § Methods › Loss function ↔ cellniche/model.py, lines 8–101 · score 0.59 · log softmax, log probabilities, row, Loss
  7. [7] § Methods › Training module ↔ cellniche/model.py, lines 104–175 · score 0.57 · graph convolutional, node features, encoder, matrix, training, module
  8. [8] § Methods › Cellular identity representation ↔ cellniche/utils.py, lines 132–172 · score 0.54 · feature matrix, expression matrix, hot, phenotypic, gene, CellNiche
  9. [9] § Results › CellNiche shows accurate and robust performance on spatial transcriptomics data ↔ cellniche/utils.py, lines 561–640 · score 0.54 · silhouette score, spatial domain, AMI, ARI, Macro, Clustering
  10. [10] § Methods › Training module ↔ cellniche/model.py, lines 104–175 · score 0.53 · node embedding, node features, layer, edge, graph, module
  11. [11] § Methods › Differential gene expression analysis ↔ cellniche/utils.py, lines 175–221 · score 0.52 · expression matrices, Scanpy, sum, Log, genes, CellNiche

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 · 871 lines · 28 KB · MIT · 6 matches

  2. import os
  3. import random
  4. import numpy as np
  5. import pandas as pd
  6. import torch
  7. import scipy
  8. import scipy.sparse as sps
  9. import logging
  10. import torch.nn.functional as F
  11. import scanpy as sc
  12. from natsort import natsorted
  13. from scipy.sparse import coo_matrix
  14. from sklearn.preprocessing import LabelEncoder
  15. from sklearn.neighbors import NearestNeighbors
  16. from sklearn.cluster import KMeans
  17. from sklearn.metrics import (
  18. adjusted_rand_score,
  19. normalized_mutual_info_score,
  20. adjusted_mutual_info_score,
  21. f1_score,
  22. silhouette_score,
  24. homogeneity_score,
  25. v_measure_score,
  26. fowlkes_mallows_score
  27. )
  30. from torch_sparse import SparseTensor
  31. from torch_geometric.utils import to_undirected
  33. from typing import Optional, Union, Any, Tuple, List
  34. from numpy.typing import ArrayLike
  35. from scipy.stats import entropy
  36. from sklearn.metrics import silhouette_samples
  39. def to_float_tensor(arr):
  40. """Safely convert numpy array / tensor -> float32 tensor w/o grad."""
  41. if isinstance(arr, torch.Tensor):
  42. return arr.clone().detach().float()
  43. else: # numpy / list
  44. return torch.as_tensor(arr, dtype=torch.float)
  46. def _resolve_squidpy_connectivity_key(adata, connectivity_key: str = "spatial") -> str:
  47. """
  48. Resolve Squidpy connectivity key in adata.obsp.
  50. Squidpy usually stores the spatial graph as:
  51. adata.obsp["spatial_connectivities"]
  53. If users pass connectivity_key="spatial", this function will look for
  54. "spatial_connectivities". If users directly pass "spatial_connectivities",
  55. it will also work.
  56. """
  57. if connectivity_key is None:
  58. connectivity_key = "connectivities"
  60. # Case 1: user directly provides the obsp key
  61. if connectivity_key in adata.obsp:
  62. return connectivity_key
  64. # Case 2: user provides Squidpy key_added prefix, e.g. "spatial"
  65. candidate = f"{connectivity_key}_connectivities"
  66. if candidate in adata.obsp:
  67. return candidate
  69. raise KeyError(
  70. f"Cannot find Squidpy spatial connectivity graph in adata.obsp. "
  71. f"Tried '{connectivity_key}' and '{candidate}'. "
  72. f"Available obsp keys: {list(adata.obsp.keys())}. "
  73. f"For multi-slice data, please precompute the graph using "
  74. f"squidpy.gr.spatial_neighbors(..., library_key=..., key_added='{connectivity_key}')."
  75. )
  78. def _edge_index_from_squidpy_obsp(
  79. adata,
  80. connectivity_key: str = "spatial",
  81. ) -> torch.LongTensor:
  82. """
  83. Build edge_index from a Squidpy-generated spatial connectivity matrix.
  85. Expected input:
  86. adata.obsp["spatial_connectivities"]
  87. or:
  88. adata.obsp[f"{connectivity_key}_connectivities"]
  90. Returns:
  91. edge_index: torch.LongTensor with shape [2, num_edges]
  92. """
  93. obsp_key = _resolve_squidpy_connectivity_key(adata, connectivity_key)
  95. adj = adata.obsp[obsp_key]
  97. # Ensure sparse matrix
  98. if not sps.issparse(adj):
  99. adj = sps.csr_matrix(adj)
  101. # Convert to boolean adjacency
  102. adj = adj.astype(bool)
  104. # Convert to LIL for efficient diagonal modification
  105. if isinstance(adj, sps.csr_matrix):
  106. adj = adj.tolil()
  107. else:
  108. adj = adj.tolil()
  110. # Remove self-loops
  111. adj.setdiag(0)
  113. # Back to CSR and remove explicit zeros
  114. adj = adj.tocsr()
  115. adj.eliminate_zeros()
  117. # Extract nonzero indices
  118. row, col = adj.nonzero()
  120. edge_index = torch.tensor(
  121. np.array([row, col]),
  122. dtype=torch.long,
  123. )
  125. logging.info(
  126. f"Using precomputed Squidpy graph from adata.obsp['{obsp_key}']: "
  127. f"{adata.n_obs} nodes, {edge_index.shape[1]} edges."
  128. )
  130. return edge_index
  132. def load_data(
  133. data_path: str,
  134. dataset: str,
  135. phenoLabels: str,
  136. nicheLabels: Optional[str],
  137. embedding_type: str,
  138. radius: Optional[float],
  139. k_neighborhood: int,
  140. hvg: bool,
  141. n_hvg: int,
  142. multi_slice: bool = False,
  143. connectivity_key: str = "spatial",
  144. embedding_key: Optional[str] = None,
  145. ) -> Tuple[torch.FloatTensor, torch.LongTensor, np.ndarray, Any, int, Optional[torch.FloatTensor]]:
  146. """
  147. Load AnnData from .h5ad, build node features, edge index, and labels.
  149. Args:
  150. data_path: Directory containing the .h5ad files.
  151. dataset: Filename (without extension) to load.
  152. phenoLabels: Column name in `adata.obs` for phenotype labels (one-hot).
  153. nicheLabels: Column name in `adata.obs` for true labels (or None to skip).
  154. embedding_type: One of 'pheno_expr', 'pheno', 'expr'.
  155. radius: Radius threshold (if not None) for radius graph.
  156. k_neighborhood: Number of neighbors for kNN graph if radius is None.
  157. hvg: Whether to select highly variable genes for expression.
  158. multi_slice: bool = False,
  159. connectivity_key: str = "spatial",
  160. embedding_key: Optional[str] = None,
  162. Returns:
  163. x: Node feature matrix (one-hot or expr) as FloatTensor.
  164. edge_index: LongTensor[2, E] of graph edges.
  165. y: True label array of shape [N].
  166. adata: The AnnData object.
  167. n_classes: Number of unique labels in y.
  168. expr: Expression matrix as FloatTensor if needed, else None.
  169. """
  170. # 1) Read AnnData
  171. path = os.path.join(data_path, f"{dataset}.h5ad")
  172. adata = sc.read_h5ad(path).copy()
  175. # 2) Build phenotype one-hot features
  176. valid_embedding_types = ["pheno_expr", "pheno", "expr", "embedding"]
  177. if embedding_type not in valid_embedding_types:
  178. raise ValueError(
  179. f"Unknown embedding_type: {embedding_type}. "
  180. f"Expected one of {valid_embedding_types}."
  181. )
  182. # 3) Build phenotype one-hot features only when needed
  183. onehot = None
  185. if embedding_type in ["pheno", "pheno_expr"]:
  186. if phenoLabels is None:
  187. raise ValueError(
  188. "phenoLabels is required when embedding_type is "
  189. f"'{embedding_type}', but got phenoLabels=None."
  190. )
  192. if phenoLabels not in adata.obs:
  193. raise KeyError(
  194. f"phenoLabels='{phenoLabels}' was not found in adata.obs. "
  195. f"Available obs columns: {list(adata.obs.columns)}"
  196. )
  198. pheno = adata.obs[phenoLabels].astype(str)
  199. ph_le = LabelEncoder().fit(pheno)
  200. ph_idx = ph_le.transform(pheno)
  202. onehot = torch.nn.functional.one_hot(
  203. torch.from_numpy(ph_idx),
  204. num_classes=len(ph_le.classes_)
  205. ).float()
  208. # 4) Prepare expression matrix if needed
  209. expr = None
  211. if embedding_type in ["pheno_expr", "expr"]:
  212. temp_adata = adata.copy()
  213. if hvg:
  214. # # way 1
  215. # logging.info(f"hvg way1")
  216. # sc.pp.highly_variable_genes(temp_adata, n_top_genes=n_hvg, flavor='seurat_v3')
  217. # temp_adata = temp_adata[:,temp_adata.var.highly_variable]
  218. # temp_adata.raw=adata
  219. # sc.pp.normalize_total(temp_adata, target_sum=1e4,inplace=True)
  220. # sc.pp.log1p(temp_adata)
  221. # sc.pp.scale(temp_adata)
  223. # way 2
  224. sc.pp.highly_variable_genes(
  225. temp_adata,
  226. flavor="seurat_v3",
  227. n_top_genes=n_hvg,
  228. )
  229. sc.pp.normalize_total(temp_adata, target_sum=1e4)
  230. sc.pp.log1p(temp_adata)
  231. temp_adata = temp_adata[:, temp_adata.var["highly_variable"]].copy()
  233. mat = temp_adata.X
  235. if scipy.sparse.isspmatrix(mat):
  236. arr = mat.toarray()
  237. else:
  238. arr = np.asarray(mat)
  240. expr = torch.from_numpy(arr).float()
  241. del temp_adata
  243. # 5) For embedding_type="embedding", load features from adata.obsm[embedding_key]
  244. embedding = None
  246. if embedding_type == "embedding":
  247. if embedding_key is None:
  248. raise ValueError(
  249. "embedding_key is required when embedding_type='embedding'. "
  250. "Please provide the key of the embedding stored in adata.obsm, "
  251. "for example embedding_key='X_scVI' or embedding_key='X_pca'."
  252. )
  254. if embedding_key not in adata.obsm:
  255. raise KeyError(
  256. f"embedding_key='{embedding_key}' was not found in adata.obsm. "
  257. f"Available obsm keys: {list(adata.obsm.keys())}"
  258. )
  260. emb_arr = adata.obsm[embedding_key]
  262. if scipy.sparse.isspmatrix(emb_arr):
  263. emb_arr = emb_arr.toarray()
  264. else:
  265. emb_arr = np.asarray(emb_arr)
  267. if emb_arr.ndim != 2:
  268. raise ValueError(
  269. f"adata.obsm['{embedding_key}'] must be a 2D matrix, "
  270. f"but got shape {emb_arr.shape}."
  271. )
  273. if emb_arr.shape[0] != adata.n_obs:
  274. raise ValueError(
  275. f"adata.obsm['{embedding_key}'] has {emb_arr.shape[0]} rows, "
  276. f"but adata has {adata.n_obs} cells."
  277. )
  279. embedding = torch.from_numpy(emb_arr).float()
  282. # 6) Build graph edge_index
  283. if multi_slice:
  284. logging.warning(
  285. "multi_slice=True detected. "
  286. "For multi-slice or multi-sample data, CellNiche expects a precomputed "
  287. "sample-aware spatial graph generated by Squidpy"
  288. )
  290. edge_index = _edge_index_from_squidpy_obsp(
  291. adata,
  292. connectivity_key=connectivity_key,
  293. )
  295. else:
  296. # Original single-slice logic
  297. if "edgeList" in adata.uns:
  298. edge_np = np.array(adata.uns["edgeList"])
  300. # Support both shape [2, E] and [E, 2]
  301. if edge_np.ndim != 2:
  302. raise ValueError("adata.uns['edgeList'] must be a 2D array.")
  304. if edge_np.shape[0] == 2:
  305. edge_index = torch.from_numpy(edge_np).long()
  306. elif edge_np.shape[1] == 2:
  307. edge_index = torch.from_numpy(edge_np.T).long()
  308. else:
  309. raise ValueError(
  310. "adata.uns['edgeList'] should have shape [2, E] or [E, 2]."
  311. )
  313. edge_index = to_undirected(edge_index)
  315. else:
  316. # choose coords
  317. if "spatial" in adata.obsm and adata.obsm["spatial"] is not None:
  318. coords = adata.obsm["spatial"]
  319. else:
  320. coords = adata.obs[["x", "y"]].to_numpy()
  322. if radius is not None:
  323. nbrs = NearestNeighbors(radius=radius).fit(coords)
  324. _, idxs = nbrs.radius_neighbors(coords)
  326. rows_list, cols_list = [], []
  327. for i, neighbors in enumerate(idxs):
  328. # remove self-loop
  329. neighbors = neighbors[neighbors != i]
  330. rows_list.extend([i] * len(neighbors))
  331. cols_list.extend(neighbors.tolist())
  333. rows = np.asarray(rows_list)
  334. cols = np.asarray(cols_list)
  336. else:
  337. nbrs = NearestNeighbors(n_neighbors=k_neighborhood + 1).fit(coords)
  338. _, idxs = nbrs.kneighbors(coords)
  340. rows = np.repeat(np.arange(coords.shape[0]), k_neighborhood)
  341. cols = idxs[:, 1:].flatten()
  343. mat = coo_matrix(
  344. (np.ones_like(rows), (rows, cols)),
  345. shape=(coords.shape[0], coords.shape[0]),
  346. )
  347. mat = mat + mat.T # make undirected
  348. edge_index = torch.from_numpy(
  349. np.vstack(mat.nonzero()).astype(np.int64)
  350. )
  352. neighbors_count = np.array([len(neighbors) for neighbors in idxs])
  353. average_neighbors = neighbors_count.mean()
  354. logging.info(f"Average number of neighbors per node: {average_neighbors}")
  356. # 7) Encode true labels from nicheLabels if provided
  357. if nicheLabels is not None and nicheLabels in adata.obs:
  358. true_vals = adata.obs[nicheLabels].astype(str)
  359. nl_encoder = LabelEncoder().fit(true_vals)
  360. y = nl_encoder.transform(true_vals)
  361. n_classes = len(nl_encoder.classes_)
  362. else:
  363. # default dummy labels: all-zero, one class
  364. y = np.zeros(adata.n_obs, dtype=int)
  365. n_classes = 1
  368. # 8) Return according to embedding type
  369. if embedding_type == "pheno_expr":
  370. logging.info(
  371. f"Loaded {dataset}: "
  372. f"{onehot.shape[0]} nodes, {edge_index.shape[1]} edges, "
  373. f"{onehot.shape[-1]} phenotype features, "
  374. f"{expr.shape[-1]} expression features"
  375. )
  376. return to_float_tensor(onehot), edge_index, y, adata, n_classes, to_float_tensor(expr)
  378. elif embedding_type == "pheno":
  379. logging.info(
  380. f"Loaded {dataset}: "
  381. f"{onehot.shape[0]} nodes, {edge_index.shape[1]} edges, "
  382. f"{onehot.shape[-1]} phenotype features"
  383. )
  384. return to_float_tensor(onehot), edge_index, y, adata, n_classes, None
  386. elif embedding_type == "expr":
  387. logging.info(
  388. f"Loaded {dataset}: "
  389. f"{expr.shape[0]} nodes, {edge_index.shape[1]} edges, "
  390. f"{expr.shape[-1]} expression features"
  391. )
  392. return to_float_tensor(expr), edge_index, y, adata, n_classes, None
  394. elif embedding_type == "embedding":
  395. logging.info(
  396. f"Loaded {dataset}: "
  397. f"{embedding.shape[0]} nodes, {edge_index.shape[1]} edges, "
  398. f"{embedding.shape[-1]} embedding features from adata.obsm['{embedding_key}']"
  399. )
  400. return to_float_tensor(embedding), edge_index, y, adata, n_classes, None
  402. def setup_seed(seed: int) -> None:
  403. """
  404. Set random seed for reproducibility across Python, NumPy, Torch, and CUDA.
  406. Args:
  407. seed (int): The seed to set.
  408. """
  409. random.seed(seed)
  410. np.random.seed(seed)
  411. torch.manual_seed(seed)
  412. torch.cuda.manual_seed_all(seed)
  413. # torch.backends.cudnn.deterministic = True
  414. # torch.backends.cudnn.benchmark = False
  416. def create_sparse_tensor_from_edges(
  417. rows: list[int],
  418. cols: list[int],
  419. sparse_size: tuple[int, int],
  420. device: torch.device = torch.device("cpu"),
  421. ) -> SparseTensor:
  422. """
  423. Create a SparseTensor from row/col indices.
  425. Args:
  426. rows (list[int]): Row indices.
  427. cols (list[int]): Column indices.
  428. sparse_size (tuple[int,int]): Matrix size.
  429. device (torch.device): Device for tensor.
  431. Returns:
  432. SparseTensor
  433. """
  434. vals = torch.ones(len(rows), device=device)
  435. return SparseTensor(
  436. row=torch.tensor(rows, device=device),
  437. col=torch.tensor(cols, device=device),
  438. value=vals,
  439. sparse_sizes=sparse_size,
  440. )
  442. def sparse_intersection_and_union(
  443. adj1: SparseTensor,
  444. adj2: SparseTensor,
  445. strategy: str = "and",
  446. ) -> SparseTensor:
  447. """
  448. Compute intersection or union of two sparse adjacency matrices.
  450. Args:
  451. adj1, adj2 (SparseTensor): Input graphs.
  452. strategy (str): 'and' or 'or'.
  454. Returns:
  455. SparseTensor
  456. """
  457. rows1, cols1 = adj1.storage.row(), adj1.storage.col()
  458. rows2, cols2 = adj2.storage.row(), adj2.storage.col()
  459. device = rows1.device
  461. set1 = set(zip(rows1.tolist(), cols1.tolist()))
  462. set2 = set(zip(rows2.tolist(), cols2.tolist()))
  464. if strategy == "and":
  465. common = set1 & set2
  466. else:
  467. common = set1 | set2
  469. if not common:
  470. return SparseTensor(sparse_sizes=adj1.sparse_sizes())
  472. rows, cols = zip(*common)
  473. return create_sparse_tensor_from_edges(rows, cols, adj1.sparse_sizes(), device)
  475. def get_positivePairs(
  476. subAdj: SparseTensor,
  477. features: Optional[torch.Tensor] = None,
  478. strategy: str = "freq",
  479. ) -> SparseTensor:
  480. """
  481. Generate positive pair adjacency based on strategy.
  483. Args:
  484. subAdj (SparseTensor): Stochastic subgraph adjacency.
  485. features (Tensor): Node features.
  486. strategy (str): 'freq', 'sim', 'and', 'or'.
  488. Returns:
  489. SparseTensor: positive adjacency.
  490. """
  491. row, col, val = subAdj.storage.row(), subAdj.storage.col(), subAdj.storage.value()
  492. # Frequency-based mask
  493. freq_thresh = subAdj.sum(dim=1) / subAdj.storage.colptr()[1:]
  494. mask = val > freq_thresh[row]
  495. rows, cols, vals = row[mask], col[mask], val[mask]
  496. freq_adj = SparseTensor(row=rows, col=cols, value=vals, sparse_sizes=subAdj.sparse_sizes())
  498. if strategy == "freq":
  499. return freq_adj
  501. if features is None:
  502. raise ValueError("Features required for non-freq strategy.")
  504. # Similarity-based mask
  505. f_row, f_col = features[row], features[col]
  506. sim_vals = F.cosine_similarity(f_row, f_col, dim=1)
  507. sim_vals[row == col] = 0
  508. sim_adj = SparseTensor(row=row, col=col, value=sim_vals, sparse_sizes=subAdj.sparse_sizes())
  509. sim_thresh = sim_adj.sum(dim=1) / sim_adj.storage.colptr()[1:]
  510. sim_mask = sim_vals > sim_thresh[row]
  511. sim_rows, sim_cols, sim_vals = row[sim_mask], col[sim_mask], sim_vals[sim_mask]
  512. sim_based = SparseTensor(row=sim_rows, col=sim_cols, value=sim_vals, sparse_sizes=subAdj.sparse_sizes())
  514. if strategy == "sim":
  515. return sim_based
  517. # AND / OR combination
  518. return sparse_intersection_and_union(freq_adj, sim_based, strategy)
  520. def match_labels(true_labels, predicted_labels, n_classes):
  521. from scipy.optimize import linear_sum_assignment as linear_assignment
  523. cost_matrix = np.zeros((n_classes, n_classes))
  525. for i in range(n_classes):
  526. for j in range(n_classes):
  527. cost_matrix[i, j] = np.sum((true_labels == i) & (predicted_labels == j))
  529. row_ind, col_ind = linear_assignment(-cost_matrix)
  531. new_labels = np.copy(predicted_labels)
  532. for i, j in zip(row_ind, col_ind):
  533. new_labels[predicted_labels == j] = i
  534. return new_labels
  536. def refine_spatial_domains(y_pred, coord, n_neighbors=6):
  537. nbrs = NearestNeighbors(n_neighbors=n_neighbors + 1).fit(coord)
  538. distances, indices = nbrs.kneighbors(coord)
  539. indices = indices[:, 1:]
  541. y_refined = pd.Series(index=y_pred.index, dtype='object')
  543. for i in range(y_pred.shape[0]):
  544. y_pred_count = y_pred[indices[i, :]].value_counts()
  546. if y_pred[i] in y_pred_count.index:
  547. if (y_pred_count.loc[y_pred[i]] < n_neighbors / 2) and (y_pred_count.max() > n_neighbors / 2):
  548. y_refined[i] = y_pred_count.idxmax()
  549. else:
  550. # y_refined[i] = y_pred[i] # waring
  551. y_refined.iloc[i] = y_pred[i]
  552. else:
  553. y_refined.iloc[i] = y_pred[i]
  555. y_refined = pd.Categorical(
  556. values=y_refined.astype('U'),
  557. categories=natsorted(map(str, y_refined.unique())),
  558. )
  559. return y_refined
  561. def clustering_st(
  562. adata: Any,
  563. n_clusters: int,
  564. features: Optional[Union[torch.Tensor, np.ndarray]] = None,
  565. true_labels: Optional[np.ndarray] = None,
  566. refine: bool = False,
  567. ) -> Tuple[Any, dict]:
  568. """
  569. Perform KMeans clustering and compute evaluation metrics.
  571. Args:
  572. adata (AnnData): Annotated data object.
  573. features (Tensor or ndarray): Embeddings.
  574. n_clusters (int): Number of clusters.
  575. true_labels (ndarray): Ground-truth labels.
  577. Returns:
  578. adata (AnnData): Updated with 'kmeans' clusters.
  579. metrics (dict): Cluster evaluation metrics.
  580. """
  581. # 1) Convert to numpy
  582. if torch.is_tensor(features):
  583. feats = features.cpu().numpy()
  584. else:
  585. feats = features
  586. # 2) Run KMeans
  587. km = KMeans(n_clusters=n_clusters, max_iter=5000, n_init=10)
  588. # km = KMeans(n_clusters=n_clusters, max_iter=10000, n_init=20)
  589. raw_labels = km.fit_predict(feats).astype(int)
  591. # 3) Store raw labels
  592. adata.obs['kmeans'] = pd.Categorical(raw_labels)
  593. clustering_results = {'kmeans': raw_labels}
  595. # 4) Optional spatial refinement
  596. if refine:
  597. # spatial coords must exist
  598. coords = adata.obsm.get('spatial')
  599. if coords is None:
  600. raise ValueError("adata.obsm['spatial'] needed for refinement")
  601. for method, labels in list(clustering_results.items()):
  602. refined = refine_spatial_domains(pd.Series(labels), coords)
  603. refined = refined.astype(int)
  604. col = f"{method}_refined"
  605. adata.obs[col] = pd.Categorical(refined)
  606. clustering_results[col] = refined
  608. # 5) Compute metrics
  609. metrics_results: dict = {}
  610. if true_labels is not None:
  611. for method, labels in clustering_results.items():
  612. # align predicted → true
  613. aligned = match_labels(true_labels, labels, n_clusters)
  615. acc = (aligned == true_labels).mean()
  616. nmi = normalized_mutual_info_score(true_labels, aligned)
  617. ari = adjusted_rand_score(true_labels, aligned)
  618. ami = adjusted_mutual_info_score(true_labels, aligned)
  619. f1m = f1_score(true_labels, aligned, average='macro')
  620. f1i = f1_score(true_labels, aligned, average='micro')
  621. sil = silhouette_score(feats, true_labels)
  623. FMI = fowlkes_mallows_score(true_labels, aligned)
  624. v_measure = v_measure_score(true_labels, aligned)
  625. homogeneity = homogeneity_score(true_labels, aligned)
  627. metrics_results[method] = {
  628. 'Acc': acc,
  629. 'NMI': nmi,
  630. 'AMI': ami,
  631. 'ARI': ari,
  632. 'F1 Macro': f1m,
  633. 'F1 Micro': f1i,
  634. 'Silhouette': sil,
  635. 'Fowlkes-Mallows': FMI,
  636. 'V-Measure': v_measure,
  637. 'Homogeneity': homogeneity
  638. }
  640. return adata, metrics_results
  644. def _rng(random_state: Optional[int] = None) -> np.random.Generator:
  645. """Return a NumPy Generator with the requested seed (or global RNG)."""
  646. return np.random.default_rng(random_state)
  649. def _nearest_neighbors(
  650. x: np.ndarray, k: int, **kwargs
  651. ) -> np.ndarray:
  652. """
  653. Return indices of the *k* nearest neighbours for every point in *x*.
  655. The first neighbour returned by ``sklearn`` is the query point itself,
  656. so we discard it.
  657. """
  658. nn = NearestNeighbors(n_neighbors=k + 1, **kwargs).fit(x)
  659. indices = nn.kneighbors(x, return_distance=False)[:, 1:] # drop self‑index
  660. return indices
  663. def _encode_labels(labels: ArrayLike) -> np.ndarray:
  664. """
  665. Map arbitrary label values to consecutive integers starting from 0.
  667. This simplifies downstream use of ``np.bincount`` and avoids
  668. large sparse counts when label values are not contiguous.
  669. """
  670. labels = np.asarray(labels)
  671. _, encoded = np.unique(labels, return_inverse=True)
  672. return encoded
  675. # ---------------------------------------------------------------------
  676. # 1. Entropy of Batch Mixing
  677. # ---------------------------------------------------------------------
  678. def compute_entropy_batch_mixing(
  679. embeddings: np.ndarray,
  680. batch_labels: ArrayLike,
  681. k: int = 50,
  682. normalize: bool = True,
  683. **nn_kwargs,
  684. ) -> float:
  685. """
  686. Average entropy of batch labels in the *k*‑NN neighbourhood of each cell.
  688. Parameters
  689. ----------
  690. embeddings
  691. Low‑dimensional representation of shape *(n_cells, n_dims)*.
  692. batch_labels
  693. Iterable of length *n_cells* with one label per cell.
  694. k
  695. Number of neighbours (*excluding* the query cell) to consider.
  696. normalize
  697. If ``True`` (default) divide by the maximal entropy
  698. ``log(n_batches)``, yielding values in ``[0, 1]``.
  699. **nn_kwargs
  700. Additional arguments forwarded to :class:`sklearn.neighbors.NearestNeighbors`.
  702. Returns
  703. -------
  704. float
  705. Mean entropy across all cells.
  706. """
  707. if k < 1:
  708. raise ValueError("k must be ≥ 1")
  710. batch_labels = _encode_labels(batch_labels)
  711. indices = _nearest_neighbors(embeddings, k=k, **nn_kwargs)
  713. n_batches = int(batch_labels.max()) + 1
  714. max_ent = np.log(n_batches) if normalize else 1.0
  716. entropies = []
  717. for nbr in indices:
  718. counts = np.bincount(batch_labels[nbr], minlength=n_batches)
  719. probs = counts / k # guaranteed non‑negative, summing to 1
  720. ent = entropy(probs) / max_ent if max_ent > 0 else 0.0
  721. entropies.append(ent)
  723. return float(np.mean(entropies))
  726. # ---------------------------------------------------------------------
  727. # 2. iLISI
  728. # ---------------------------------------------------------------------
  729. def compute_ilisi(
  730. embeddings: np.ndarray,
  731. batch_labels: ArrayLike,
  732. k: int = 90,
  733. **nn_kwargs,
  734. ) -> np.ndarray:
  735. """
  736. Compute the *inverse* Local Inverse Simpson’s Index (iLISI).
  738. For each cell *i*::
  740. iLISI_i = 1 − (# neighbours from same batch) / k
  742. Thus, 0 indicates perfect batch isolation; 1 indicates perfect mixing.
  744. Parameters
  745. ----------
  746. embeddings
  747. *(n_cells, n_dims)* array.
  748. batch_labels
  749. Iterable with one batch label per cell.
  750. k
  751. Number of neighbours (*excluding* the query cell) to consider.
  752. **nn_kwargs
  753. Extra arguments for :class:`sklearn.neighbors.NearestNeighbors`.
  755. Returns
  756. -------
  757. np.ndarray
  758. Vector of length *n_cells* with iLISI scores.
  759. """
  760. batch_labels = _encode_labels(batch_labels)
  761. indices = _nearest_neighbors(embeddings, k=k, **nn_kwargs)
  763. same_batch = (batch_labels[indices] == batch_labels[:, None]).sum(axis=1)
  764. ilisi = 1.0 - (same_batch / k)
  765. return ilisi
  768. # ---------------------------------------------------------------------
  769. # 3. Seurat Alignment Score (SAS)
  770. # ---------------------------------------------------------------------
  771. def compute_seurat_alignment_score(
  772. embeddings: np.ndarray,
  773. batch_labels: ArrayLike,
  774. neighbor_frac: float = 0.01,
  775. n_repeats: int = 3,
  776. random_state: Optional[int] = None,
  777. **nn_kwargs,
  778. ) -> float:
  779. """
  780. Seurat Alignment Score (Butler *et al.*, Cell 2018).
  782. The score estimates how well batches mix after integration by repeatedly
  783. down‑sampling to equal batch sizes and measuring the proportion of
  784. cross‑batch neighbours.
  786. Parameters
  787. ----------
  788. embeddings
  789. *(n_cells, n_dims)* array.
  790. batch_labels
  791. Iterable with one batch label per cell.
  792. neighbor_frac
  793. Fraction of the (sub‑sampled) cells to use as *k* in *k*‑NN.
  794. Must be in ``(0, 1]``.
  795. n_repeats
  796. Number of random sub‑samples to average.
  797. random_state
  798. Seed for reproducibility.
  799. **nn_kwargs
  800. Extra arguments for :class:`sklearn.neighbors.NearestNeighbors`.
  802. Returns
  803. -------
  804. float
  805. Mean SAS across repeats (1 = perfect mixing, 0 = no mixing).
  806. """
  807. if not (0 < neighbor_frac <= 1):
  808. raise ValueError("neighbor_frac must be in (0, 1]")
  810. rng = _rng(random_state)
  811. batch_labels = _encode_labels(batch_labels)
  812. batch_indices = [np.where(batch_labels == b)[0] for b in np.unique(batch_labels)]
  813. min_size = min(len(idx) for idx in batch_indices)
  814. n_batches = len(batch_indices)
  816. scores = []
  817. for _ in range(n_repeats):
  818. # balanced subsample
  819. sel = np.concatenate([rng.choice(idx, min_size, replace=False) for idx in batch_indices])
  820. x_sub, y_sub = embeddings[sel], batch_labels[sel]
  822. k = max(int(round(len(sel) * neighbor_frac)), 1)
  823. indices = _nearest_neighbors(x_sub, k=k, **nn_kwargs)
  825. same_batch = (y_sub[indices] == y_sub[:, None]).sum(axis=1).mean()
  826. score = (k - same_batch) * n_batches / (k * (n_batches - 1))
  827. scores.append(min(score, 1.0)) # numerical guard
  829. return float(np.mean(scores))
  832. # ---------------------------------------------------------------------
  833. # 4. ASW‑batch
  834. # ---------------------------------------------------------------------
  835. def compute_avg_silhouette_width_batch(
  836. embeddings: np.ndarray,
  837. batch_labels: ArrayLike,
  838. cell_types: ArrayLike,
  839. min_cells: int = 3,
  840. **silhouette_kwargs,
  841. ) -> float:
  842. """
  843. Average Silhouette Width computed per cell‑type, then averaged.
  845. Parameters
  846. ----------
  847. ...
  848. min_cells
  849. Minimum number of cells a cell‑type must have to be included.
  850. """
  851. x = embeddings
  852. y = _encode_labels(batch_labels)
  853. ct = _encode_labels(cell_types)
  855. scores = []
  856. for t in np.unique(ct):
  857. mask = ct == t
  858. n = mask.sum()
  859. n_labels = np.unique(y[mask]).size
  860. # Skip if too few cells OR labels≈cells (invalid for silhouette)
  861. if n < min_cells or n_labels < 2 or n_labels >= n:
  862. scores.append(0.0)
  863. continue
  864. try:
  865. s = silhouette_samples(x[mask], y[mask], **silhouette_kwargs)
  866. scores.append((1.0 - np.abs(s)).mean())
  867. except ValueError:
  868. scores.append(0.0)
  870. return float(np.mean(scores))

utils.py at commit af58974, under MIT · at the source

Overview

Authors: Zhongming Liang1,2,3, Bingxu Zhong4, Mingqi Jiao1, Yong Wang1,5,6, Shiping Liu1,2,3
ORCID iDs: Zhongming Liang, Bingxu Zhong, Mingqi Jiao, Yong Wang, Shiping Liu
  1. Key Laboratory of Systems Health Science of Zhejiang Province, School of Life Science, Hangzhou Institute for Advanced Study, University of Chinese Academy of Sciences,Hangzhou, China
  2. State Key Laboratory of Genome and Multi-omics Technologies, BGI Research,Hangzhou, China
  3. Key Laboratory of Spatial Omics of Zhejiang Province, BGI Research,Hangzhou, China
  4. SJTU-Yale Joint Center for Biostatistics and Data Science, Department of Bioinformatics and Biostatistics, School of Life Sciences and Biotechnology, Shanghai Jiao Tong University,Shanghai, China
  5. State Key Laboratory of Mathematical Sciences, Academy of Mathematics and Systems Science, Chinese Academy of Sciences,Beijing, China
  6. School of Mathematics, University of Chinese Academy of Sciences, Chinese Academy of Sciences,Beijing, China
Institutions: University of Chinese Academy of Sciences (China); BGI Research (China); Shanghai Jiao Tong University (China); Academy of Mathematics and Systems Science (China)
Journal: Nature communications, volume 17, issue 1, article 5547
Dates: received 12 August 2025; accepted 24 March 2026; published online 22 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1038/s41467-026-71759-4 · PMID 42020427 · PMCID PMC13287597 · OpenAlex W7155187838
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), human (organism), mouse (organism), other condition (population), cellular / molecular (subfield)
Methods: Statistics, Smoothing, state filtering, decompositions, Machine learning
Keywords: Computational models, Machine learning, Computer modelling, Computer science
MeSH: Carcinoma, Non-Small-Cell Lung*, Cellular Microenvironment*, Lung Neoplasms*, Tumor Microenvironment*, Animals, Brain, Clustering Algorithms, Humans, Machine Learning, Mice (* major topic)
Topic: Single-cell and spatial transcriptomics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: National Key Research and Development Program of China (2022YFA1004800); Strategic Priority Research Program of the Chinese Academy of Sciences (XDB1350000); CAS Project for Young Scientists in Basic Research (YSBR-077); National Natural Science Foundation of China (12025107, 12571550, 12326610)
Citations: cited by 1 paper (Europe PMC); 65 references in the paper
Research resources: RRID:SCR_024672

Abstract

Deciphering cellular microenvironments at atlas scale remains challenging because molecular identity, spatial context, and platform heterogeneity are tightly coupled. Here we present CellNiche, a scalable contrastive-learning framework that identifies and characterizes cellular microenvironments from spatial omics data using cell-centric spatial-proximity subgraphs. CellNiche combines spatial co-localization and molecular co-expression cues to learn microenvironment-aware embeddings. Across spatial omics datasets from multiple platforms (>10 million cells in total), scaling experiments show improved representations with more training data and competitive clustering and embedding-quality performance with efficient computation. In a multi-sample human non-small-cell lung cancer (NSCLC) cohort, CellNiche identifies conserved and sample-specific tumor and immune microenvironments and captures localized spatial transitions. In four independent mouse brain atlases, CellNiche integrates 293 slices into a unified virtual brain map for cross-atlas annotation transfer and spatial refinement.

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

QIFEIDKN/STGATE_pyG

License: none: the authors keep all their rights
State: the link is dead, verified on 29 September 2026
Evidence: found in the paper
Software Heritage: not archived
Found in: the text, “STAGATE (v1.0.0)”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 29 September 2026: the link is dead
  • 29 September 2026: the link is dead
At the source: github.com/QIFEIDKN/STGATE_pyG

Super-LzzZ/CellNiche

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: af58974ded7cf57299a9f8952d4cc6dffee39c6f, 4 May 2026
Languages: Jupyter (11), Python (6)
Size: 29 files, 17 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (pyproject.toml), 11 notebooks
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (8 files), NumPy (7 files), pandas (5 files), Scanpy (5 files), anndata (4 files), Matplotlib (4 files), PyTorch Geometric (4 files), scikit-learn (4 files), seaborn (4 files), SciPy (2 files), NetworkX (1 file), Squidpy (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/Super-LzzZ/CellNiche

Zenodo 19143524

License: MIT
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 29 September 2026: the link answers (HTTP 200)
  • 29 September 2026: the link answers (HTTP 200)
At the source:

Code availability

The software package implementing the CellNiche algorithm has been deposited at GitHub https://github.com/Super-LzzZ/CellNiche under the MIT license. The version associated with this study has been archived at Zenodo (10.5281/zenodo.19143524)65.

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:

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

The osmFISH dataset of mouse somatosensory cortex is available at https://github.com/drieslab/spatial-datasets (https://github.com/drieslab/spatial-datasets.)28. The mouse spleen CODEX dataset is available at https://data.mendeley.com/datasets/zjnpwh8m5b/130. The STARMap dataset of mouse brain is available at https://singlecell.broadinstitute.org/single_cell/study/SCP183032. The human CRC CODEX dataset is available at https://data.mendeley.com/datasets/mpjzbtfgfr/137. The NSCLC CosMx dataset is available at https://nanostring.com/products/cosmx-spatial-molecular-imager/nsclc-ffpe-dataset/27. The spatial transcriptomics atlases of mouse brain are available at https://singlecell.broadinstitute.org/single_cell/study/SCP1830 (Atlas 1)32, https://doi.brainimagelibrary.org/doi/10.35077/g.610 (Atlas 2)31, https://doi.brainimagelibrary.org/doi/10.35077/act-bag (Atlas 3)33, https://info.vizgen.com/mouse-brain-map (Atlas 4)34. The mouse E16.5 whole embryo Stereo-seq data is available at https://db.cngb.org/stomics/mosta/download/36. Source data are provided in this paper.

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, 5 authors, 4 keywords, 10 MeSH terms, 1 funder, 57 references, 1 RRID.

Cite

This paper

Liang, Z., Zhong, B., Jiao, M., Wang, Y., & Liu, S. (2026). CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning. Nature communications, 17(1), 5547. https://doi.org/10.1038/s41467-026-71759-4

BibTeX

@article{liang2026cellniche,
author = {Liang, Zhongming and Zhong, Bingxu and Jiao, Mingqi and Wang, Yong and Liu, Shiping},
title = {{CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning}},
journal = {Nature communications},
year = {2026},
month = apr,
volume = {17},
number = {1},
pages = {5547},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-71759-4},
url = {https://doi.org/10.1038/s41467-026-71759-4},
pmid = {42020427},
pmcid = {PMC13287597}
}

RIS

TY - JOUR
AU - Liang, Zhongming
AU - Zhong, Bingxu
AU - Jiao, Mingqi
AU - Wang, Yong
AU - Liu, Shiping
TI - CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/04/22
VL - 17
IS - 1
SP - 5547
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-71759-4
UR - https://doi.org/10.1038/s41467-026-71759-4
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-71759-4",
"type": "article-journal",
"title": "CellNiche represents cellular microenvironments in atlas-scale spatial omics data with contrastive learning",
"container-title": "Nature communications",
"author": [
{
"family": "Liang",
"given": "Zhongming"
},
{
"family": "Zhong",
"given": "Bingxu"
},
{
"family": "Jiao",
"given": "Mingqi"
},
{
"family": "Wang",
"given": "Yong"
},
{
"family": "Liu",
"given": "Shiping"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "5547",
"DOI": "10.1038/s41467-026-71759-4",
"PMID": "42020427",
"PMCID": "PMC13287597",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-71759-4",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
22
]
]
}
}

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.1038/s41592-026-03194-8 [code]
Beyond benchmarking: an expert-guided consensus approach to spatially aware clustering.
Journal: Nature methods
In common: Squidpy, PyTorch Geometric, anndata, 8 other tools, 12 references
[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: Squidpy, PyTorch Geometric, anndata, 9 other tools, 6 references
[3] 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: PyTorch Geometric, anndata, Scanpy, 7 other tools, 10 references
[4] doi:10.1093/bioinformatics/btag540 [code]
Deciphering spatial heterogeneity by multimodal spatial transcriptomics modelling with SpatialModal.
Journal: Bioinformatics (Oxford, England)
In common: Squidpy, PyTorch Geometric, anndata, 8 other tools, mouse, 7 references
[5] doi:10.1038/s42003-026-10462-y [code]
SpaDC enables sequence-based integrative analysis and regulatory inference of spatial chromatin accessibility data.
Journal: Communications biology
In common: Squidpy, anndata, Scanpy, 7 other tools, mouse, 5 references
[6] doi:10.1038/s41467-026-68596-w [code]
Spatial cartography of human thymus enables the geopositioning of lineage transcription factors in rare mimetic thymic epithelial cells.
Journal: Nature communications
In common: Squidpy, anndata, Scanpy, 8 other tools, cellular / molecular, 4 references
[7] doi:10.1186/s12859-026-06490-4 [code]
Tissueformer: extending single-cell foundation models to predict population-level phenotypes.
Journal: BMC bioinformatics
In common: anndata, PyTorch, seaborn, 5 other tools, other condition, mouse, cellular / molecular, 7 references
[8] doi:10.1016/j.isci.2026.116906 [code]
Evaluating exon skipping in the central nervous system in Duchenne muscular dystrophy using spatial transcriptomics.
Journal: iScience
In common: Squidpy, anndata, Scanpy, 5 other tools, other condition, mouse, 6 references
[9] doi:10.1093/bib/bbag404 [code]
Navigating cell maps by deep learning integration of single-cell and spatially resolved transcriptomics.
Journal: Briefings in bioinformatics
In common: PyTorch Geometric, anndata, Scanpy, 6 other tools, other condition, mouse, cellular / molecular, 5 references
[10] doi:10.1093/bib/bbag298 [code]
Empowering multifaceted analysis of spatial transcriptomics data with RGAST.
Journal: Briefings in bioinformatics
In common: PyTorch Geometric, anndata, Scanpy, 7 other tools, mouse, 5 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.