OSCR

Tissueformer: extending single-cell foundation models to predict population-level phenotypes.

Code ↔ Paper

13 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 13 matches
  1. [1] § Methods › Pseudobulk and type composition benchmarks ↔ applications/brain_annotation/benchmarks.py, lines 1–52 · score 0.88 · random forest classifier, max depth, logistic regression, scikit-learn, lbfgs, leaf
  2. [2] § Methods › Deep learning benchmarks ↔ applications/brain_annotation/benchmarks.py, lines 740–824 · score 0.84 · weight decay, ScRAT, cosine, schedule, warmup, dropout
  3. [3] § Methods › Data and tokenization › Data description: mouse brains ↔ colormycells/colormap.py, lines 48–141 · score 0.80 · perceptual distance, perceptually uniform, pseudobulk expression, ColorMyCells, LUV, MDS
  4. [4] § Methods › Brain map visualization ↔ applications/brain_annotation/paper_figures/fig3/compute_visp_area.py, lines 443–531 · score 0.74 · flatmap pixel, cuML, smooth, GPU, kernel, SVC
  5. [5] § Methods › Data and tokenization › Data description: mouse brains ↔ applications/brain_annotation/figures/utils.py, lines 104–159 · score 0.69 · perceptual distance, perceptually uniform, LUV, MDS, matrix, colormaps
  6. [6] § Methods › TissueFormer architecture: hyperparameters of this study ↔ applications/brain_annotation/benchmarks.py, lines 740–824 · score 0.67 · learning rate warmup, PyTorch, decay, hidden, optimizer, Adam
  7. [7] § Results › Annotating cell groups with TissueFormer ↔ applications/brain_annotation/benchmarks.py, lines 827–889 · score 0.64 · Logistic regression, deep learning, random forest, bulk, CellCnn, ScRAT
  8. [8] § Methods › Deep learning benchmarks ↔ applications/brain_annotation/paper_figures/fig2/hyperparameters.ipynb, lines 139–170 · score 0.63 · CellCNN, ScAGG, ScRAT, Hyperparameters, benchmarked
  9. [9] § Methods › Data and tokenization › Data description: mouse brains ↔ applications/brain_annotation/paper_figures/fig3/cell_type_viz.ipynb, lines 518–657 · score 0.61 · brain slice, AnnData, ccf streamlines, axis
  10. [10] § Results › Single-cell profiles are not informative of cortical area ↔ applications/brain_annotation/paper_figures/fig2/single_cell_accuracy.py, lines 6–25 · score 0.61 · Murine Geneformer, logistic regression, random forest, neighbors, single cell, classifier
  11. [11] § Results › Predicting COVID-19 severity from blood transcriptomics ↔ applications/brain_annotation/paper_figures/fig2/hyperparameters.ipynb, lines 139–170 · score 0.56 · CellCNN, ScAGG, ScRAT, accuracy
  12. [12] § Results › Single-cell profiles are not informative of cortical area ↔ applications/brain_annotation/paper_figures/fig2/hyperparameters.ipynb, lines 172–212 · score 0.53 · logistic regression, brain accuracy, Validation accuracy, LR, bars, Figure 2
  13. [13] § Results › Predicted cortical maps ↔ applications/brain_annotation/paper_figures/fig3/gene_viz.ipynb, lines 489–498 · score 0.53 · Brinp3, Coro6, Nell1, Rcan2, Tshz2, Zfpm2

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 · 892 lines · 32 KB · MIT · 4 matches

  1. """
  2. Benchmarking Configuration
  3. =========================
  5. This configuration file controls the benchmarking pipeline for brain cell type classification models.
  6. It defines parameters for Random Forest and Logistic Regression classifiers, along with data handling
  7. and experiment tracking settings.
  9. Dependencies
  10. -----------
  11. - hydra-core
  12. - wandb (Weights & Biases)
  13. - scikit-learn
  14. - numpy
  15. - anndata (when using AnnData features)
  17. Configuration Sections
  18. --------------------
  19. random_forest:
  20. Parameters for sklearn RandomForestClassifier
  21. - n_estimators: Number of trees (default: 200)
  22. - max_depth: Maximum tree depth (default: 15)
  23. - min_samples_split: Minimum samples for split (default: 5)
  24. - min_samples_leaf: Minimum samples per leaf (default: 2)
  25. - max_features: Features per tree (default: 0.33)
  26. - bootstrap: Bootstrap samples (default: true)
  27. - class_weight: Class weighting strategy (default: null)
  29. logistic_regression:
  30. Parameters for sklearn LogisticRegression
  31. - max_iter: Maximum iterations (default: 1000)
  32. - multi_class: Classification strategy (default: 'multinomial')
  33. - solver: Optimization algorithm (default: 'lbfgs')
  35. Debug Options
  36. ------------
  37. debug: false # Enable debug mode with reduced dataset
  38. debug_args:
  39. on_adata: false # Use AnnData features
  40. resample_adata: true # Resample AnnData to match dataset size
  42. Experiment Types
  43. --------------
  44. run_bulk_expression_rf: false # Run Random Forest on bulk expression
  45. run_bulk_expression_lr: true # Run Logistic Regression on bulk expression
  46. run_h3type_rf: false # Run Random Forest on H3 types
  47. run_h3type_lr: false # Run Logistic Regression on H3 types
  49. Usage Examples
  50. ------------
  51. # Run default benchmarks
  52. python benchmarks.py
  54. # Enable debug mode
  55. python benchmarks.py debug=true
  57. # Run specific experiment
  58. python benchmarks.py run_bulk_expression_rf=true
  60. # Override Random Forest parameters
  61. python benchmarks.py random_forest.n_estimators=300 random_forest.max_depth=20
  63. Output
  64. ------
  65. Results are saved to ${output_dir} (default: 'benchmarks/') including:
  66. - Model performance metrics
  67. - Feature importance plots
  68. - Confusion matrices
  69. - Weights & Biases logs (if enabled)
  71. Notes
  72. -----
  73. - Set debug=true for quick iteration with reduced dataset
  74. - Enable wandb tracking by configuring wandb/default.yaml
  75. - Use debug_args.on_adata=true when working with AnnData features
  76. """
  78. import os
  79. import hydra
  80. import wandb
  81. import numpy as np
  82. import anndata as ad
  83. from omegaconf import DictConfig, OmegaConf
  84. from sklearn.ensemble import RandomForestClassifier
  85. from sklearn.linear_model import LogisticRegression, LogisticRegressionCV
  86. from sklearn.preprocessing import StandardScaler
  87. from collections import Counter
  88. from typing import Dict, List, Tuple, Optional
  89. from datasets import load_from_disk, DatasetDict, Dataset
  90. import torch
  91. from torch.utils.data import DataLoader
  92. from sklearn.model_selection import train_test_split
  93. from transformers import PreTrainedModel, TrainingArguments
  94. import json
  95. import scipy
  96. from sklearn.utils import check_random_state
  97. from sklearn.preprocessing import OneHotEncoder
  99. # Import necessary components from train.py
  100. from tissueformer.samplers import (
  101. GroupedSpatialTrainer
  102. )
  104. from transformers import PretrainedConfig
  106. class DummyConfig(PretrainedConfig):
  107. def __init__(self, **kwargs):
  108. super().__init__(**kwargs)
  110. class DummyModel(PreTrainedModel):
  111. config_class = DummyConfig
  113. def __init__(self, config):
  114. super().__init__(config)
  116. def forward(self, *args, **kwargs):
  117. return None
  119. def get_dataloaders(datasets: DatasetDict, cfg: DictConfig) -> Dict[str, DataLoader]:
  120. """
  121. Create dataloaders using GroupedSpatialTrainer infrastructure.
  122. """
  123. # Create minimal training arguments
  124. training_args = TrainingArguments(
  125. output_dir=cfg.output_dir,
  126. per_device_train_batch_size=cfg.data.group_size*32,
  127. per_device_eval_batch_size=cfg.data.group_size*32,
  128. remove_unused_columns=False, # Important for GroupedSpatialTrainer
  129. )
  131. dummy_config = DummyConfig()
  133. # Initialize trainer with dummy model
  134. trainer = GroupedSpatialTrainer(
  135. model=DummyModel(dummy_config),
  136. args=training_args,
  137. train_dataset=datasets["train"],
  138. eval_dataset=datasets["validation"],
  139. spatial_group_size=cfg.data.group_size,
  140. spatial_label_key="labels",
  141. coordinate_key='CCF_streamlines',
  142. additional_feature_keys=['raw_counts'],
  143. sampling_strategy=cfg.data.sampling.strategy,
  144. hex_scaling=cfg.data.sampling.hex_scaling,
  145. reflect_points=cfg.data.sampling.reflect_points,
  146. use_train_hex_grid_on_eval=cfg.data.sampling.use_train_hex_grid_on_eval,
  147. max_radius_expansions=cfg.data.sampling.max_radius_expansions,
  148. group_within_keys=cfg.data.sampling.group_within_keys
  149. )
  151. # Get dataloaders
  152. dataloaders = {
  153. "train": trainer.get_train_dataloader(),
  154. "validation": trainer.get_eval_dataloader(datasets["validation"]),
  155. "test": trainer.get_test_dataloader(datasets["test"])
  156. }
  158. return dataloaders
  160. def load_and_align_anndata(
  161. train_filenames: List[str],
  162. test_filenames: List[str],
  163. data_dir: str,
  164. dataset: DatasetDict,
  165. coordinate_key = "CCF_streamlines",
  166. ) -> Tuple[ad.AnnData, ad.AnnData]:
  167. """
  168. Load and concatenate AnnData files, ensuring alignment with dataset indices.
  169. Handles train and test files separately to match the original tokenization.
  171. Args:
  172. train_filenames: List of h5ad filenames for training data
  173. test_filenames: List of h5ad filenames for test data
  174. data_dir: Directory containing h5ad files
  175. dataset: HuggingFace dataset to align with
  177. Returns:
  178. Tuple of (train_adata, test_adata)
  179. """
  180. print("Loading and processing AnnData files...")
  182. def process_files(filenames: List[str]) -> ad.AnnData:
  183. """Helper function to process a list of files"""
  184. adatas = []
  185. for filename in filenames:
  186. filepath = os.path.join(data_dir, filename)
  187. print(f"Loading {filepath}")
  188. adata = ad.read_h5ad(filepath)
  190. # Filter cells with invalid CCF coordinates
  191. valid_mask = ~np.isnan(adata.obsm[coordinate_key]).any(axis=1)
  192. adata = adata[valid_mask]
  193. adatas.append(adata)
  195. return ad.concat(adatas, join='outer', fill_value=0)
  197. # Process train and test files separately
  198. train_adata = process_files(train_filenames)
  199. test_adata = process_files(test_filenames)
  201. # Verify alignment with dataset
  202. print("Verifying alignment with dataset...")
  204. # Check first 10000 cells in train dataset
  205. test_dataset = dataset['test']
  206. dataset_h3types = np.array(test_dataset[:10000]['H3_type'])
  207. adata_h3types = test_adata.obs['H3_type'].values[:10000]
  209. if not np.array_equal(dataset_h3types, adata_h3types):
  210. mismatches = np.where(dataset_h3types != adata_h3types)[0]
  211. mismatch_info = [
  212. f"Index {i}: Dataset H3_type: {dataset_h3types[i]}, AnnData H3_type: {adata_h3types[i]}"
  213. for i in mismatches
  214. ]
  215. raise ValueError(
  216. "Mismatch found in H3 types:\n" + "\n".join(mismatch_info)
  217. )
  219. print("Alignment verification passed!")
  220. return train_adata, test_adata
  222. def prepare_datasets(dataset_dict: DatasetDict, cfg: DictConfig) -> DatasetDict:
  223. """
  224. Prepare train/validation split from dataset.
  225. """
  226. train_dataset = dataset_dict["train"]
  228. # Create train/validation split
  229. train_idx, val_idx = train_test_split(
  230. np.arange(len(train_dataset)),
  231. test_size=cfg.data.validation_split,
  232. random_state=cfg.seed
  233. )
  235. # Add unique ids if not present
  236. if 'uuid' not in train_dataset.features:
  237. dataset_dict["test"] = dataset_dict["test"].add_column(
  238. "uuid",
  239. np.arange(len(dataset_dict["test"]))
  240. )
  241. train_dataset = train_dataset.add_column(
  242. "uuid",
  243. np.arange(len(dataset_dict["train"]))
  244. )
  246. # Select train and validation datasets
  247. val_dataset = train_dataset.select(val_idx)
  248. train_dataset = train_dataset.select(train_idx)
  250. # Limit dataset size if in debug mode
  251. if hasattr(cfg.data, 'max_train_samples') and cfg.data.max_train_samples is not None:
  252. train_dataset = train_dataset.select(range(min(len(train_dataset), cfg.data.max_train_samples)))
  254. # Limit validation/test size if specified
  255. if hasattr(cfg.data, 'max_eval_samples') and cfg.data.max_eval_samples is not None:
  256. val_dataset = val_dataset.select(range(min(len(val_dataset), cfg.data.max_eval_samples)))
  257. dataset_dict["test"] = dataset_dict["test"].select(range(min(len(dataset_dict["test"]), cfg.data.max_eval_samples)))
  259. # rename the labels to match the model's expected input
  260. if hasattr(cfg.data, 'label_key'):
  261. train_dataset = train_dataset.rename_column(cfg.data.label_key, "labels")
  262. val_dataset = val_dataset.rename_column(cfg.data.label_key, "labels")
  263. dataset_dict["test"] = dataset_dict["test"].rename_column(cfg.data.label_key, "labels")
  265. return DatasetDict({
  266. "train": train_dataset,
  267. "validation": val_dataset,
  268. "test": dataset_dict["test"]
  269. })
  271. def setup_wandb(cfg: DictConfig):
  272. """Initialize W&B logging"""
  273. wandb.init(
  274. project=cfg.wandb.project,
  275. entity=cfg.wandb.entity,
  276. name=cfg.wandb.name,
  277. group=cfg.wandb.group,
  278. tags=cfg.wandb.tags,
  279. notes=cfg.wandb.notes,
  280. config=OmegaConf.to_container(cfg, resolve=True),
  281. )
  283. def evaluate_method(
  284. predictions: np.ndarray,
  285. labels: np.ndarray,
  286. indices: np.ndarray,
  287. prefix: str,
  288. label_names: Dict,
  289. output_dir: str
  290. ) -> Dict:
  291. """Evaluate predictions and save results."""
  293. # Extract metrics
  294. from sklearn.metrics import balanced_accuracy_score
  295. metrics = {
  296. "accuracy": (predictions == labels).mean(),
  297. "balanced_accuracy": balanced_accuracy_score(labels, predictions),
  298. }
  300. # Save predictions
  301. output_dict = {
  302. 'predictions': predictions,
  303. 'labels': labels,
  304. 'indices': indices,
  305. 'label_names': label_names
  306. }
  307. np.save(os.path.join(output_dir, f"{prefix}_predictions.npy"), output_dict)
  309. # Log to wandb
  310. wandb.log({f"{prefix}_{k}": v for k, v in metrics.items()})
  312. return metrics
  314. def prepare_h3type_data(dataset: DatasetDict) -> Tuple[Dict[str, np.ndarray], Dict[str, int], Dict[str, Dict[int, int]]]:
  315. """
  316. Prepare H3 type data for fast access during training.
  317. Creates both type mapping and index mapping.
  318. """
  319. # Create type mapping
  320. all_h3_types = set()
  321. for split in dataset.values():
  322. all_h3_types.update(split['H3_type'])
  323. type_to_idx = {h3_type: idx for idx, h3_type in enumerate(sorted(list(all_h3_types)))}
  325. # Create numpy arrays and index mappings for fast access
  326. h3_arrays = {}
  327. index_maps = {}
  329. for split, dset in dataset.items():
  330. # Create mapping from dataset index to array index
  331. index_maps[split] = {
  332. idx: i for i, idx in enumerate(dset['uuid'])
  333. }
  335. # Create array with H3 type indices
  336. h3_arrays[split] = np.array([
  337. type_to_idx[t] for t in dset['H3_type']
  338. ])
  340. return h3_arrays, type_to_idx, index_maps
  342. def get_h3type_histogram(
  343. indices: np.ndarray,
  344. h3_array: np.ndarray,
  345. index_map: Dict[int, int],
  346. n_types: int
  347. ) -> np.ndarray:
  348. """
  349. Create histogram of H3 types for a group of cells using vectorized operations.
  351. Args:
  352. indices: Original dataset indices
  353. h3_array: Pre-computed array of H3 type indices
  354. index_map: Mapping from dataset indices to array indices
  355. n_types: Total number of H3 types
  356. """
  357. # Ensure indices is 2D: (n_groups, group_size)
  358. indices = np.asarray(indices)
  359. if indices.ndim == 1:
  360. indices = indices.reshape(1, -1) # One group with multiple cells
  361. batch_size = indices.shape[0]
  362. histogram = np.zeros((batch_size, n_types))
  364. for i, batch_indices in enumerate(indices):
  365. # Map dataset indices to array indices
  366. array_indices = [index_map[idx] for idx in batch_indices]
  367. # Get H3 types using mapped indices
  368. type_indices = h3_array[array_indices]
  369. histogram[i] = np.bincount(type_indices, minlength=n_types)
  371. total = histogram[i].sum()
  372. if total > 0:
  373. histogram[i] /= total
  375. return histogram
  377. def create_dataset_from_anndata(adata: ad.AnnData, cfg: DictConfig) -> Dataset:
  378. """
  379. Create a HuggingFace Dataset directly from AnnData object.
  380. """
  381. # Extract features (gene expression)
  382. features = np.array(adata.X.todense() if scipy.sparse.issparse(adata.X) else adata.X)
  384. print(f"Features shape: {features.shape}")
  386. # Extract coordinates
  387. coordinates = adata.obsm["CCF_streamlines"]
  389. # Extract area labels using the same logic as in tokenize_cells.py
  390. with open('data/files/area_ancestor_id_map.json', 'r') as f:
  391. area_ancestor_id_map = json.load(f)
  392. with open('data/files/area_name_map.json', 'r') as f:
  393. area_name_map = json.load(f)
  395. area_name_map['0'] = 'outside_brain'
  396. annotation2area_int = {0.0:0}
  397. for a in area_ancestor_id_map.keys():
  398. higher_area_id = area_ancestor_id_map[str(int(a))][1] if len(area_ancestor_id_map[str(int(a))])>1 else a
  399. annotation2area_int[float(a)] = int(higher_area_id)
  401. unique_areas = np.unique(list(annotation2area_int.values()))
  402. area_classes = np.arange(len(unique_areas))
  403. id2id = {float(k):v for (k,v) in zip(unique_areas, area_classes)}
  404. annotation2area_class = {k: id2id[int(v)] for k,v in annotation2area_int.items()}
  406. # Convert CCF annotations to area labels
  407. labels = np.array([annotation2area_class[x] for x in adata.obs['CCFano']])
  409. # Extract H3 types
  410. h3types = adata.obs['H3_type'].values
  412. # # Filter dataset to only include cells for which the CCF_streamlines is not nans
  413. # same as tokenized_dataset = tokenized_dataset.filter(lambda x: not np.isnan(np.sum(x['CCF_streamlines'])))
  414. # Filter out indices where CCF_streamlines contains NaN values
  415. valid_mask = ~np.isnan(coordinates).any(axis=1)
  416. features = features[valid_mask]
  417. coordinates = coordinates[valid_mask]
  418. labels = labels[valid_mask]
  419. h3types = h3types[valid_mask]
  420. indices = np.arange(len(adata))[valid_mask]
  422. # Create dataset
  423. return Dataset.from_dict({
  424. 'expression': features,
  425. 'CCF_streamlines': coordinates,
  426. 'labels': labels,
  427. 'H3_type': h3types,
  428. 'uuid': indices
  429. })
  431. def prepare_features_from_anndata(
  432. train_adata: ad.AnnData,
  433. test_adata: ad.AnnData,
  434. cfg: DictConfig,
  435. scaler: StandardScaler,
  436. feature_type: str
  437. ) -> Dict[str, Tuple[np.ndarray, np.ndarray, np.ndarray]]:
  438. """
  439. Prepare features directly from AnnData objects.
  440. Returns dict with keys 'train', 'validation', 'test', each containing (features, labels, indices)
  441. """
  442. # Create datasets from AnnData
  443. train_valid_dataset = create_dataset_from_anndata(train_adata, cfg)
  444. test_dataset = create_dataset_from_anndata(test_adata, cfg)
  446. rng = check_random_state(cfg.seed)
  448. # Split train/validation
  449. train_idx, val_idx = train_test_split(
  450. np.arange(len(train_valid_dataset)),
  451. test_size=cfg.data.validation_split,
  452. random_state=rng
  453. )
  455. # Select splits using Dataset.select()
  456. train_dataset = train_valid_dataset.select(train_idx)
  457. val_dataset = train_valid_dataset.select(val_idx)
  459. if feature_type == "h3type":
  460. # One-hot encode H3 types
  461. # Collect all unique H3 types from all splits
  462. all_h3_types = np.concatenate([
  463. train_dataset['H3_type'],
  464. val_dataset['H3_type'],
  465. test_dataset['H3_type']
  466. ])
  467. encoder = OneHotEncoder(sparse_output=False)
  468. # Fit on all types
  469. encoder.fit(all_h3_types.reshape(-1, 1))
  470. # Transform each split
  471. train_features = encoder.transform(np.array(train_dataset['H3_type']).reshape(-1, 1))
  472. val_features = encoder.transform(np.array(val_dataset['H3_type']).reshape(-1, 1))
  473. test_features = encoder.transform(np.array(test_dataset['H3_type']).reshape(-1, 1))
  474. else:
  475. # Extract and scale continuous features
  476. train_features = np.array(train_dataset['expression'])
  477. val_features = np.array(val_dataset['expression'])
  478. test_features = np.array(test_dataset['expression'])
  480. # Only apply scaling for non-categorical features
  481. train_features = scaler.fit_transform(train_features)
  482. val_features = scaler.transform(val_features)
  483. test_features = scaler.transform(test_features)
  485. # Extract features and labels as numpy arrays
  486. train_features = scaler.fit_transform(train_features)
  487. val_features = scaler.transform(val_features)
  488. test_features = scaler.transform(test_features)
  490. # Verify no NaN or infinite values
  491. if np.any(np.isnan(train_features)) or np.any(np.isinf(train_features)):
  492. raise ValueError("Training features contain NaN or infinite values")
  494. print(f"Train features final shape: {train_features.shape}")
  495. print(f"Test features final shape: {test_features.shape}")
  497. output = {
  498. 'train': (
  499. train_features,
  500. np.array(train_dataset['labels']),
  501. train_idx
  502. ),
  503. 'validation': (
  504. val_features,
  505. np.array(val_dataset['labels']),
  506. val_idx
  507. ),
  508. 'test': (
  509. test_features,
  510. np.array(test_dataset['labels']),
  511. np.arange(len(test_dataset))
  512. )
  513. }
  515. if cfg.debug_args.resample_adata:
  516. # Resample the data
  517. print("Resampling the adata")
  518. for name, (features, labels, indices) in output.items():
  519. resampled_indices = np.random.choice(range(len(indices)), len(indices), replace=True)
  520. output[name] = (features[resampled_indices], labels[resampled_indices], indices[resampled_indices])
  522. return output
  524. def run_classifier(
  525. datasets: DatasetDict,
  526. adata: Optional[Tuple[ad.AnnData, ad.AnnData]],
  527. cfg: DictConfig,
  528. classifier_type: str,
  529. feature_type: str
  530. ) -> None:
  531. """Generic function to run different classifiers on different feature types."""
  533. # Initialize classifier and scaler
  534. if classifier_type == "random_forest":
  535. clf = RandomForestClassifier(**cfg.random_forest)
  536. elif classifier_type == "logistic_regression":
  537. clf = LogisticRegression(**cfg.logistic_regression)
  538. else:
  539. raise ValueError(f"Unknown classifier type: {classifier_type}")
  541. scaler = StandardScaler()
  543. # If using direct AnnData path
  544. if cfg.data.group_size == 1 and cfg.debug_args.on_adata:
  545. train_adata, test_adata = adata
  546. splits = prepare_features_from_anndata(train_adata, test_adata, cfg, scaler, feature_type)
  548. # Train classifier
  549. train_features, train_labels, train_indices = splits['train']
  550. clf.fit(train_features, train_labels)
  552. # Evaluate
  553. for name, (features, labels, indices) in splits.items():
  554. predictions = clf.predict(features)
  555. evaluate_method(
  556. predictions,
  557. labels,
  558. indices,
  559. f"{classifier_type}_{feature_type}_{name}",
  560. cfg.data.label_names,
  561. cfg.output_dir
  562. )
  563. return
  565. # Original dataloader-based path
  566. dataloaders = get_dataloaders(datasets, cfg)
  568. # Prepare H3 type data if needed
  569. if feature_type == "h3type":
  570. h3_arrays, type_to_idx, index_maps = prepare_h3type_data(datasets)
  571. n_types = len(type_to_idx)
  573. # Training
  574. print(f"Collecting training features for {classifier_type} on {feature_type}...")
  575. train_features = []
  576. train_labels = []
  577. train_indices = []
  579. for batch in dataloaders["train"]:
  580. indices = batch['indices'].cpu().numpy() # these are uuid = indices in the original dataset['train'] before splitting
  581. train_indices.extend(indices)
  583. if feature_type == "bulk_expression":
  584. features = batch['raw_counts'].mean(1).cpu().numpy()
  585. else: # h3type
  586. features = get_h3type_histogram(indices, h3_arrays['train'], index_maps['train'], n_types)
  588. # get
  590. train_features.append(features)
  591. train_labels.append(batch['labels'].cpu().numpy())
  593. train_features = np.vstack(train_features)
  594. train_features = scaler.fit_transform(train_features)
  595. train_labels = np.concatenate(train_labels)
  597. print("Train features:", train_features.shape)
  598. print("Train labels:", train_labels.shape)
  600. print(f"Training {classifier_type}...")
  601. # Check for NaN/Inf values
  602. assert not np.any(np.isnan(train_features)), "Features contain NaN values"
  603. assert not np.any(np.isinf(train_features)), "Features contain infinite values"
  605. # Verify feature array is contiguous
  606. if not train_features.flags['C_CONTIGUOUS']:
  607. train_features = np.ascontiguousarray(train_features)
  608. # Fit with verbose logging
  609. clf.fit(train_features, train_labels)
  611. # Evaluate on all sets
  612. for name in ['train', 'validation', 'test']:
  613. loader = dataloaders[name]
  614. print(f"Evaluating on {name} set...")
  615. predictions = []
  616. labels = []
  617. indices = []
  619. for batch in loader:
  620. batch_indices = batch['indices'].cpu().numpy()
  621. indices.extend(batch_indices)
  623. if feature_type == "bulk_expression":
  624. features = batch['raw_counts'].mean(1).cpu().numpy()
  625. else: # h3type
  626. features = get_h3type_histogram(
  627. batch_indices,
  628. h3_arrays[name],
  629. index_maps[name],
  630. n_types
  631. )
  633. features = scaler.transform(features)
  634. pred = clf.predict(features)
  635. predictions.extend(pred)
  636. labels.extend(batch['labels'].cpu().numpy())
  638. evaluate_method(
  639. np.array(predictions),
  640. np.array(labels),
  641. np.array(indices),
  642. f"{classifier_type}_{feature_type}_{name}",
  643. cfg.data.label_names,
  644. cfg.output_dir
  645. )
  647. def run_dl_benchmark_brain(
  648. datasets: DatasetDict,
  649. cfg: DictConfig,
  650. model_name: str,
  651. ) -> None:
  652. """Run a DL benchmark on brain annotation data.
  654. Brain annotation differs from COVID: data is spatial (not donor-level),
  655. each cell has a label, and we group spatially adjacent cells into bags.
  656. """
  657. from torch.utils.data import DataLoader
  658. from tissueformer.benchmark_models.cellcnn import CellCnn
  659. from tissueformer.benchmark_models.scagg import ScAGG
  660. from tissueformer.benchmark_models.scrat import ScRAT
  661. from tissueformer.benchmark_models.data import MILDataset, CroppedMILDataset, mil_collate_fn
  662. from tissueformer.benchmark_models.trainer import BenchmarkTrainer
  663. import transformers
  665. print(f"\n--- DL benchmark: {model_name} ---")
  667. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  668. torch.manual_seed(cfg.seed)
  669. np.random.seed(cfg.seed)
  671. # Load model config
  672. model_cfg = OmegaConf.load(
  673. os.path.join(
  674. os.path.dirname(__file__),
  675. "config", "benchmark_models", f"{model_name}.yaml",
  676. )
  677. )
  678. if hasattr(cfg, "benchmark_models") and hasattr(cfg.benchmark_models, model_name):
  679. model_cfg = OmegaConf.merge(model_cfg, cfg.benchmark_models[model_name])
  681. # Use the spatial group dataloaders to get grouped bags
  682. dataloaders = get_dataloaders(datasets, cfg)
  684. # Collect all data through dataloaders into bags
  685. def collect_bags(loader, split_name):
  686. all_cells = []
  687. all_labels = []
  688. for batch in loader:
  689. raw = batch['raw_counts'].cpu().numpy() # (batch, group_size, n_genes)
  690. labs = batch['labels'].cpu().numpy() # (batch,)
  691. for i in range(raw.shape[0]):
  692. all_cells.append(raw[i])
  693. all_labels.append(labs[i])
  694. return all_cells, np.array(all_labels)
  696. train_cells, train_labels = collect_bags(dataloaders["train"], "train")
  697. val_cells, val_labels = collect_bags(dataloaders["validation"], "validation")
  698. test_cells, test_labels = collect_bags(dataloaders["test"], "test")
  700. # Each item in train_cells is already a (group_size, n_genes) array = one bag
  701. # Stack into flat expression matrix with sample indices
  702. def bags_to_mil_format(bags_list, labels_arr):
  703. expression_parts = []
  704. sample_indices = []
  705. cursor = 0
  706. for bag in bags_list:
  707. n = bag.shape[0]
  708. expression_parts.append(bag)
  709. sample_indices.append(np.arange(cursor, cursor + n))
  710. cursor += n
  711. expression = np.vstack(expression_parts).astype(np.float32)
  712. return expression, sample_indices, labels_arr
  714. train_X, train_si, train_y = bags_to_mil_format(train_cells, train_labels)
  715. val_X, val_si, val_y = bags_to_mil_format(val_cells, val_labels)
  716. test_X, test_si, test_y = bags_to_mil_format(test_cells, test_labels)
  718. # Apply preprocessing
  719. from tissueformer.benchmark_models.data import preprocess_zscore, preprocess_cp10k_log1p
  720. preprocess = model_cfg.get("preprocess", "raw")
  721. if preprocess == "zscore":
  722. scaler = StandardScaler()
  723. scaler.fit(train_X)
  724. train_X, _ = preprocess_zscore(train_X, scaler)
  725. val_X, _ = preprocess_zscore(val_X, scaler)
  726. test_X, _ = preprocess_zscore(test_X, scaler)
  727. elif preprocess == "cp10k_log1p":
  728. train_X = preprocess_cp10k_log1p(train_X)
  729. val_X = preprocess_cp10k_log1p(val_X)
  730. test_X = preprocess_cp10k_log1p(test_X)
  732. n_genes = train_X.shape[1]
  733. n_classes = int(max(train_y.max(), val_y.max(), test_y.max())) + 1
  735. # Compute class weights for imbalanced labels
  736. from tissueformer.class_weights import calculate_class_weights
  737. class_weights = calculate_class_weights(train_y, method="balanced", n_classes=n_classes)
  738. class_weights_tensor = torch.tensor(class_weights, dtype=torch.float32).to(device)
  740. # Build datasets (bags already formed, just wrap)
  741. train_ds = MILDataset(train_X, train_si, train_y)
  742. val_ds = MILDataset(val_X, val_si, val_y)
  743. test_ds = MILDataset(test_X, test_si, test_y)
  745. batch_size = model_cfg.batch_size
  746. train_loader = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=mil_collate_fn)
  747. val_loader = DataLoader(val_ds, batch_size=batch_size, shuffle=False, collate_fn=mil_collate_fn)
  748. test_loader = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=mil_collate_fn)
  750. # Build model
  751. if model_name == "cellcnn":
  752. cells_per_input = model_cfg.get("cells_per_input", 200)
  753. model = CellCnn(
  754. n_genes=n_genes, n_classes=n_classes,
  755. n_filters=model_cfg.n_filters,
  756. maxpool_percentage=model_cfg.maxpool_percentage,
  757. dropout=model_cfg.dropout,
  758. cells_per_input=cells_per_input,
  759. )
  760. optimizer = torch.optim.Adam(model.parameters(), lr=model_cfg.lr, weight_decay=model_cfg.l2_reg)
  761. l1_fn = lambda: model.l1_loss(model_cfg.l1_reg)
  762. loss_fn = torch.nn.CrossEntropyLoss(weight=class_weights_tensor)
  763. trainer = BenchmarkTrainer(
  764. model=model, optimizer=optimizer,
  765. train_loader=train_loader, val_loader=val_loader,
  766. device=device, n_epochs=model_cfg.n_epochs,
  767. early_stopping_patience=model_cfg.early_stopping_patience,
  768. l1_loss_fn=l1_fn, loss_fn=loss_fn,
  769. model_name=model_name, n_classes=n_classes,
  770. )
  771. elif model_name == "scagg":
  772. model = ScAGG(
  773. n_genes=n_genes, n_classes=n_classes,
  774. hidden_dim=model_cfg.hidden_dim,
  775. n_heads=model_cfg.n_heads, n_heads2=model_cfg.n_heads2,
  776. dropout=model_cfg.dropout,
  777. )
  778. optimizer = torch.optim.Adam(model.parameters(), lr=model_cfg.lr, weight_decay=model_cfg.weight_decay)
  779. loss_fn = torch.nn.CrossEntropyLoss(weight=class_weights_tensor, reduction=model_cfg.loss_reduction)
  780. trainer = BenchmarkTrainer(
  781. model=model, optimizer=optimizer,
  782. train_loader=train_loader, val_loader=val_loader,
  783. device=device, n_epochs=model_cfg.n_epochs,
  784. loss_fn=loss_fn, early_stopping_patience=None,
  785. model_name=model_name, n_classes=n_classes,
  786. )
  787. elif model_name == "scrat":
  788. model = ScRAT(
  789. n_genes=n_genes, n_classes=n_classes,
  790. hidden_dim=model_cfg.hidden_dim,
  791. n_heads=model_cfg.n_heads, n_layers=model_cfg.n_layers,
  792. dropout=model_cfg.dropout,
  793. )
  794. optimizer = torch.optim.Adam(model.parameters(), lr=model_cfg.lr, weight_decay=model_cfg.weight_decay)
  795. scheduler = transformers.get_cosine_schedule_with_warmup(
  796. optimizer, num_warmup_steps=model_cfg.lr_warmup_epochs,
  797. num_training_steps=model_cfg.n_epochs,
  798. )
  799. loss_fn = torch.nn.CrossEntropyLoss(weight=class_weights_tensor)
  800. trainer = BenchmarkTrainer(
  801. model=model, optimizer=optimizer,
  802. train_loader=train_loader, val_loader=val_loader,
  803. device=device, n_epochs=model_cfg.n_epochs,
  804. early_stopping_patience=model_cfg.early_stopping_patience,
  805. early_stopping_start_epoch=model_cfg.early_stopping_start_epoch,
  806. scheduler=scheduler, loss_fn=loss_fn,
  807. model_name=model_name, n_classes=n_classes,
  808. )
  809. else:
  810. raise ValueError(f"Unknown DL benchmark: {model_name}")
  812. # Train
  813. trainer.train()
  815. # Evaluate on test
  816. test_loss, test_preds, test_labels_out, test_probs = trainer.eval_epoch(test_loader)
  818. evaluate_method(
  819. test_preds, test_labels_out,
  820. np.arange(len(test_preds)),
  821. f"{model_name}_test",
  822. cfg.data.label_names if hasattr(cfg.data, 'label_names') else {},
  823. cfg.output_dir,
  824. )
  827. @hydra.main(version_base=None, config_path="config", config_name="benchmarks")
  828. def main(cfg: DictConfig) -> None:
  829. print("Running benchmarks...")
  830. # Print config
  831. print(OmegaConf.to_yaml(cfg))
  833. if cfg.debug:
  834. # Limit dataset size for faster iteration
  835. cfg.data.max_train_samples = 10000
  836. cfg.data.max_eval_samples = 10000
  838. # Setup wandb
  839. setup_wandb(cfg)
  841. # Load dataset
  842. dataset_dict = load_from_disk(cfg.data.dataset_path)
  843. datasets = prepare_datasets(dataset_dict, cfg)
  844. print(f"Loaded datasets: {datasets}")
  846. # Load AnnData if needed
  847. if cfg.debug_args.on_adata:
  848. adata = load_and_align_anndata(
  849. cfg.data.train_h5ad_files,
  850. cfg.data.test_h5ad_files,
  851. cfg.data.h5ad_directory,
  852. datasets
  853. )
  854. else:
  855. adata = None
  857. # ensure that the lengths are the same
  858. if cfg.debug_args.on_adata and cfg.debug:
  859. subsampled_idx_train = np.random.choice(len(adata[0]), len(datasets['train']), replace=False)
  860. subsampled_idx_test = np.random.choice(len(adata[1]), len(datasets['test']), replace=False)
  861. adata = (adata[0][subsampled_idx_train], adata[1][subsampled_idx_test])
  863. # Run benchmarks
  864. if cfg.run_bulk_expression_rf:
  865. run_classifier(datasets, adata, cfg, "random_forest", "bulk_expression")
  867. if cfg.run_bulk_expression_lr:
  868. run_classifier(datasets, adata, cfg, "logistic_regression", "bulk_expression")
  870. if cfg.run_h3type_rf:
  871. run_classifier(datasets, adata, cfg, "random_forest", "h3type")
  873. if cfg.run_h3type_lr:
  874. run_classifier(datasets, adata, cfg, "logistic_regression", "h3type")
  876. # Deep learning benchmarks
  877. dl_models = {
  878. "cellcnn": cfg.get("run_cellcnn", False),
  879. "scagg": cfg.get("run_scagg", False),
  880. "scrat": cfg.get("run_scrat", False),
  881. }
  883. for model_name, should_run in dl_models.items():
  884. if not should_run:
  885. continue
  886. run_dl_benchmark_brain(datasets, cfg, model_name)
  888. # Close wandb run
  889. wandb.finish()
  891. if __name__ == "__main__":
  892. main()

benchmarks.py at commit ff2b881, under MIT · at the source

Overview

Authors: Ari S. Benjamin1, Anthony Zador1
ORCID iDs: Anthony Zador
  1. Cold Spring Harbor Laboratory,Cold Spring Harbor, NY 11724 USA
Institutions: Cold Spring Harbor Laboratory (United States)
Journal: BMC bioinformatics, volume 27, issue 1, article 172
Dates: received 10 December 2025; accepted 13 May 2026; published online 4 June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1186/s12859-026-06490-4 · PMID 42243667 · PMCID PMC13466306 · OpenAlex W7163530187
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), mouse (organism), other condition (population), cellular / molecular (subfield)
Methods: Machine learning, Statistics, Preprocessing
Keywords: Spatial transcriptomics, Single-cell foundation models, Sample-level diagnostics, Brain annotation, Tissue labeling, AI for biology
MeSH: COVID-19*, Neural Networks, Computer*, Single-Cell Analysis*, Animals, Brain, Mice, Phenotype, Sequence Analysis, RNA, Single-Cell Gene Expression Analysis, Spatial Transcriptomics, Transcriptome (* major topic)
Topic: Single-cell and spatial transcriptomics (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: NIH (RF1 MH126883-01A1)
Citations: not cited yet (Europe PMC); 69 references in the paper

Abstract

Background: Single-cell RNA sequencing technologies have enabled unprecedented insights into gene expression and opened new pathways for diagnostics and tissue annotation. At present, most computational approaches for interpreting single-cell data predict labels or properties based on isolated single-cell transcriptomic profiles. This approach overlooks the cellular composition within a sample, which is often critical for inferring tissue identity or other sample-level phenotypes.

Results: To address this limitation, we introduce TissueFormer, a Transformer-based neural network that infers population-level labels from groups of single-cell RNA profiles while retaining single-cell resolution. We applied TissueFormer to two tasks: predicting COVID-19 severity from single-cell RNA sequencing of blood samples, and predicting cortical area identity from spatial transcriptomic data in mouse brains. TissueFormer outperformed single-cell foundation models and machine learning methods applied to pseudobulk and cell type composition.

Conclusions: TissueFormer’s higher performance promises more accurate diagnostics and enables the automated construction of high-resolution brain region maps in individual mice directly from spatial transcriptomic data. Applied to mice with developmental perturbations to visual input, these maps revealed a significant reduction in predicted visual cortex area, illustrating how individual differences in neuroanatomy can be quantified. More broadly, TissueFormer provides a framework for predicting any population-level phenotypes which are influenced by cellular diversity and tissue-level organization.

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

ZadorLaboratory/TissueFormer

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: ff2b881ab40e09757facc4838eea7fce536327dd, 3 April 2026
Languages: Python (44), Jupyter (12), Shell (8)
Size: 257 files, 64 scripts
Software Heritage: archived
Found in: “Data availability”
Holds: README, environment (pyproject.toml), tests, 12 notebooks
Not found: license file, CITATION.cff, continuous integration, documentation
Tools: NumPy (19 files), Matplotlib (13 files), anndata (12 files), pandas (12 files), seaborn (12 files), SciPy (7 files), PyTorch (4 files), scikit-learn (3 files), Hugging Face Transformers (3 files), CuPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
21 files
At the source: github.com/ZadorLaboratory/TissueFormer

Zenodo 15595324

License: GPL-3.0
State: the link answers, verified on 27 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
Tools: Matplotlib (2 files), NumPy (2 files), pandas (2 files), scikit-learn (2 files), SciPy (2 files), seaborn (2 files), anndata (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
5 files
At the source:

zadorlaboratory/colormycells

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 3edd4a073e9c5a052b536ea729cec5ee2cce5305, 17 July 2025
Languages: Python (2)
Size: 10 files, 2 scripts
Software Heritage: not archived
Found in: the Zenodo archive record
Holds: README, license file, CITATION.cff, environment (pyproject.toml)
Not found: tests, continuous integration, documentation
Tools: anndata (1 file), Matplotlib (1 file), NumPy (1 file), pandas (1 file), scikit-learn (1 file), SciPy (1 file), seaborn (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
4 files
At the source: github.com/ZadorLaboratory/colormycells/tree/v0.1

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:

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

All code is available at https://github.com/ZadorLaboratory/TissueFormer. Brain spatial transcriptomic data are hosted on Mendeley Data (https://doi.org/10.17632/5xfzcb4kn8.1 and https://doi.org/10.17632/8bhhk7c5n9.1). COVID-19 scRNA-seq datasets are publicly available from their original publications. All datasets used in this study are listed in Table 1.

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, volume, issue, pages, dates, 2 authors, 6 keywords, 11 MeSH terms, 1 funder, 58 references.

Cite

This paper

Benjamin, A. S., & Zador, A. (2026). Tissueformer: extending single-cell foundation models to predict population-level phenotypes. BMC bioinformatics, 27(1), 172. https://doi.org/10.1186/s12859-026-06490-4

BibTeX

@article{benjamin2026tissueformer,
author = {Benjamin, Ari S. and Zador, Anthony},
title = {{Tissueformer: extending single-cell foundation models to predict population-level phenotypes}},
journal = {BMC bioinformatics},
year = {2026},
month = jun,
volume = {27},
number = {1},
pages = {172},
publisher = {BMC},
issn = {1471-2105},
doi = {10.1186/s12859-026-06490-4},
url = {https://doi.org/10.1186/s12859-026-06490-4},
pmid = {42243667},
pmcid = {PMC13466306}
}

RIS

TY - JOUR
AU - Benjamin, Ari S.
AU - Zador, Anthony
TI - Tissueformer: extending single-cell foundation models to predict population-level phenotypes
T2 - BMC bioinformatics
J2 - BMC Bioinformatics
PY - 2026
DA - 2026/06/04
VL - 27
IS - 1
SP - 172
SN - 1471-2105
PB - BMC
DO - 10.1186/s12859-026-06490-4
UR - https://doi.org/10.1186/s12859-026-06490-4
LA - en
ER -

CSL-JSON

{
"id": "10.1186/s12859-026-06490-4",
"type": "article-journal",
"title": "Tissueformer: extending single-cell foundation models to predict population-level phenotypes",
"container-title": "BMC bioinformatics",
"author": [
{
"family": "Benjamin",
"given": "Ari S."
},
{
"family": "Zador",
"given": "Anthony"
}
],
"container-title-short": "BMC Bioinformatics",
"volume": "27",
"issue": "1",
"page": "172",
"DOI": "10.1186/s12859-026-06490-4",
"PMID": "42243667",
"PMCID": "PMC13466306",
"ISSN": "1471-2105",
"publisher": "BMC",
"URL": "https://doi.org/10.1186/s12859-026-06490-4",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
4
]
]
}
}

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/nar/gkag706 [code]
scDifformer: diffusion-based post-training for virtual cell modeling across large-scale single-cell data.
Journal: Nucleic acids research
In common: anndata, PyTorch, seaborn, 5 other tools, 8 references
[2] doi:10.1038/s41592-026-03194-8 [code]
Beyond benchmarking: an expert-guided consensus approach to spatially aware clustering.
Journal: Nature methods
In common: anndata, PyTorch, seaborn, 5 other tools, genetics / omics, 8 references
[3] 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: anndata, PyTorch, seaborn, 5 other tools, other condition, mouse, cellular / molecular, 7 references
[4] 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: anndata, PyTorch, seaborn, 5 other tools, genetics / omics, 5 references
[5] 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: anndata, PyTorch, seaborn, 5 other tools, genetics / omics, 5 references
[6] doi:10.1093/bib/bbag298 [code]
Empowering multifaceted analysis of spatial transcriptomics data with RGAST.
Journal: Briefings in bioinformatics
In common: anndata, PyTorch, seaborn, 5 other tools, genetics / omics, mouse, 4 references
[7] doi:10.1186/s13073-026-01704-z [code]
Gene expression profiling enables refined parcellation of cortical layers in the heterogeneous human cerebral cortex.
Journal: Genome medicine
In common: anndata, PyTorch, seaborn, 5 other tools, genetics / omics, mouse, cellular / molecular, 4 references
[8] doi:10.1016/j.isci.2026.117206 [code]
ReliST: A model-agnostic risk layer for spatial transcriptomics deconvolution.
Journal: iScience
In common: anndata, PyTorch, seaborn, 5 other tools, genetics / omics, mouse, 4 references
[9] doi:10.64898/2026.03.30.714220 [code]
An integrated single cell and spatial omics atlas of human prenatal development
Journal: bioRxiv (preprint)
In common: CuPy, Hugging Face Transformers, anndata, 7 other tools, 1 reference
[10] doi:10.1038/s41467-026-74171-0 [code]
Cluster replicability in single-cell and single-nucleus atlases of the mouse brain.
Journal: Nature communications
In common: anndata, pandas, SciPy, 1 other tool, genetics / omics, mouse, cellular / molecular, 6 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.