OSCR

A systems microbiology framework for reproducible multi-dataset omics integration with application to long COVID.

Code ↔ Paper

8 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 8 matches
  1. [1] § Methods and materials › Nested validation and stability analysis ↔ Discovery/resultsDNP/dnp_run2.py, lines 1–34 · score 0.82 · layer gradient, activating features, feature selection, unselected, greedy, neural
  2. [2] § Methods and materials › Nested validation and stability analysis ↔ Discovery/resultsGRACES/GRACESPortFinal.py, lines 17–33 · score 0.75 · gradient norms, dropout probability, graph, GRACES, epochs, weights
  3. [3] § Methods and materials › Nested validation and stability analysis ↔ src/features.py, lines 180–222 · score 0.70 · logistic regression, Random Forest, feature selection, trees, variables, Elastic
  4. [4] § Methods and materials › Nested validation and stability analysis ↔ src/classifiersMulti.py, lines 71–113 · score 0.60 · logistic regression, Random Forest, trees, Elastic, LASSO, ensemble
  5. [5] § Methods and materials › Nested validation and stability analysis ↔ Discovery/resultsDNP/dnp_run2.py, lines 59–94 · score 0.58 · ReLU, hidden layer, trained, MLP
  6. [6] § Methods and materials › Algorithmic framework for multi-dataset systems inference ↔ Discovery/resultsDNP/dnp_run2.py, lines 1–34 · score 0.55 · Deep Neural Pursuit, DNP
  7. [7] § Results › GSE275334 (discovery dataset) ↔ Discovery/resultsRandomForestFI/selectRandomForestFeatureSelection.py, lines 16–27 · score 0.53 · Random Forest feature, feature selection, RF, classifier, discovery
  8. [8] § Results › GSE275334 (discovery dataset) ↔ Discovery/resultsBoruta/ROCMLP.py, lines 42–183 · score 0.50 · ROC curve, MLP classifier, fitting, MCC, discovery

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

  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. """
  4. Deep Neural Pursuit (DNP) — Single-file PyTorch implementation + main()
  6. Implements a DNP-style greedy feature selection for HDLSS data:
  7. • Greedy addition by input-layer gradient group-norms (L2) averaged across dropout samples
  8. • Keeps unselected input columns fixed at zero (W_C = 0) during subnetwork training
  9. • Adagrad optimizer; Xavier init for newly activated feature columns
  10. • Optional bootstrap stability (Jaccard)
  12. Inputs (CSV):
  13. - --data : shape (n_samples, n_features)
  14. - --features : shape (n_features,) one name per line
  15. - --labels : shape (n_samples,) binary labels {0,1}
  17. Primary outputs:
  18. - selected_genes_dnp.csv (ordered feature names)
  19. - dnp_report.txt (run summary)
  20. - stability_report.txt (if --stability-runs > 0)
  22. Additional outputs:
  23. - data_reduced.csv (X restricted to selected columns, same sample order)
  24. - features_reduced.csv (selected feature names, ordered)
  25. - indices_reduced.txt (0-based column indices, ordered)
  26. """
  28. import math
  29. import argparse
  30. import numpy as np
  31. import pandas as pd
  32. import torch
  33. import torch.nn as nn
  34. import torch.nn.functional as F
  36. #np.random.seed(42)
  37. # Optional: sklearn for AUC
  38. try:
  39. from sklearn.metrics import roc_auc_score
  40. SKLEARN_OK = True
  41. except Exception:
  42. SKLEARN_OK = False
  45. # -----------------------------
  46. # Utilities
  47. # -----------------------------
  48. def standardize_np(X):
  49. mu = X.mean(axis=0, keepdims=True)
  50. sd = X.std(axis=0, ddof=0, keepdims=True)
  51. sd[sd == 0] = 1.0
  52. return (X - mu) / sd, mu, sd
  55. def xavier_bound(fan_in, fan_out):
  56. return math.sqrt(6.0 / (fan_in + fan_out))
  59. # -----------------------------
  60. # MLP backbone (exposes first-layer weights)
  61. # -----------------------------
  62. class MLP(nn.Module):
  63. def __init__(self, input_dim, hidden_layers=(50, 30, 15), dropout_p=0.5):
  64. super().__init__()
  65. self.dropout_p = float(dropout_p)
  67. self.first = nn.Linear(input_dim, hidden_layers[0], bias=True)
  68. nn.init.zeros_(self.first.weight)
  69. nn.init.zeros_(self.first.bias)
  71. blocks = []
  72. prev = hidden_layers[0]
  73. for h in hidden_layers[1:]:
  74. blocks += [nn.Linear(prev, h), nn.ReLU(inplace=True), nn.Dropout(p=self.dropout_p)]
  75. prev = h
  76. self.hidden = nn.Sequential(*blocks)
  78. self.out = nn.Linear(prev, 1) # single logit
  79. nn.init.zeros_(self.out.weight)
  80. nn.init.zeros_(self.out.bias)
  82. def forward(self, x):
  83. z = self.first(x)
  84. z = F.relu(z)
  85. z = F.dropout(z, p=self.dropout_p, training=self.training)
  86. if len(self.hidden) > 0:
  87. z = self.hidden(z)
  88. logit = self.out(z)
  89. return logit.squeeze(1)
  91. @property
  92. def W1(self):
  93. # shape: [hidden1, input_dim]
  94. return self.first.weight
  97. # -----------------------------
  98. # DNP Classifier
  99. # -----------------------------
  100. class DNPClassifier:
  101. """
  102. PyTorch DNP:
  103. - Greedy selection via ||grad(W1[:, j])||_2 (averaged across dropout passes)
  104. - W_C=0 for unselected columns during training
  105. - Adagrad optimizer
  106. - Xavier init for newly activated column
  107. """
  109. def __init__(
  110. self,
  111. input_dim,
  112. hidden_layers=(50, 30, 15),
  113. k_features=25,
  114. dropout_p=0.5,
  115. n_dropout_samples=12,
  116. lr=1e-2,
  117. weight_decay=0.0,
  118. batch_size=None,
  119. max_epochs_per_iter=200,
  120. early_stopping_patience=20,
  121. device="auto",
  122. seed=42,
  123. ):
  124. self.input_dim = int(input_dim)
  125. self.hidden_layers = tuple(hidden_layers)
  126. self.k_features = int(k_features)
  127. self.dropout_p = float(dropout_p)
  128. self.n_dropout_samples = int(n_dropout_samples)
  129. self.lr = float(lr)
  130. self.weight_decay = float(weight_decay)
  131. self.batch_size = batch_size
  132. self.max_epochs_per_iter = int(max_epochs_per_iter)
  133. self.early_stopping_patience = int(early_stopping_patience)
  135. # Device resolution
  136. self.device = device
  137. if self.device in (None, "auto"):
  138. self.device = "cuda" if torch.cuda.is_available() else "cpu"
  140. self.seed = int(seed)
  141. torch.manual_seed(self.seed)
  142. if torch.cuda.is_available():
  143. torch.cuda.manual_seed_all(self.seed)
  145. self.model = MLP(self.input_dim, self.hidden_layers, dropout_p=self.dropout_p).to(self.device)
  146. self.selected_mask_ = np.zeros(self.input_dim, dtype=bool) # True if selected
  147. self.ranking_ = []
  148. self.scaler_ = None # (mu, sd)
  150. # -------- data helpers --------
  151. def _to_tensor(self, X, y=None):
  152. Xt = torch.as_tensor(X, dtype=torch.float32, device=self.device)
  153. if y is None:
  154. return Xt, None
  155. yt = torch.as_tensor(y, dtype=torch.float32, device=self.device)
  156. return Xt, yt
  158. def _loader(self, X, y):
  159. if self.batch_size is None or self.batch_size >= len(X):
  160. ds = torch.utils.data.TensorDataset(X, y)
  161. return torch.utils.data.DataLoader(ds, batch_size=len(X), shuffle=False)
  162. ds = torch.utils.data.TensorDataset(X, y)
  163. return torch.utils.data.DataLoader(ds, batch_size=self.batch_size, shuffle=True)
  165. # -------- W_C = 0 enforcement --------
  166. def _zero_candidate_cols(self):
  167. with torch.no_grad():
  168. W = self.model.W1 # [hidden1, input_dim]
  169. mask = torch.as_tensor(~self.selected_mask_, device=W.device) # True = candidate
  170. W[:, mask] = 0.0
  172. def _after_step_rezero(self):
  173. self._zero_candidate_cols()
  175. # -------- train one subnetwork --------
  176. def _train_subnetwork(self, Xtr, ytr, Xval, yval):
  177. self.model.train()
  178. opt = torch.optim.Adagrad(self.model.parameters(), lr=self.lr, weight_decay=self.weight_decay)
  179. bce = nn.BCEWithLogitsLoss()
  180. loader = self._loader(Xtr, ytr)
  182. best_val = float('inf')
  183. best_state = None
  184. wait = 0
  186. for _epoch in range(self.max_epochs_per_iter):
  187. for xb, yb in loader:
  188. opt.zero_grad(set_to_none=True)
  189. logits = self.model(xb)
  190. loss = bce(logits, yb)
  191. loss.backward()
  193. # Keep candidates frozen
  194. with torch.no_grad():
  195. W = self.model.W1
  196. mask_cand = torch.as_tensor(~self.selected_mask_, device=W.device)
  197. if W.grad is not None:
  198. W.grad[:, mask_cand] = 0.0
  200. opt.step()
  201. self._after_step_rezero()
  203. # Early stopping on validation loss
  204. self.model.eval()
  205. with torch.no_grad():
  206. vloss = bce(self.model(Xval), yval).item()
  207. self.model.train()
  209. if vloss < best_val - 1e-6:
  210. best_val = vloss
  211. best_state = {k: v.detach().cpu().clone() for k, v in self.model.state_dict().items()}
  212. wait = 0
  213. else:
  214. wait += 1
  216. if wait >= self.early_stopping_patience:
  217. break
  219. if best_state is not None:
  220. self.model.load_state_dict(best_state)
  221. self._after_step_rezero()
  223. # -------- candidate scoring: average dropout gradients --------
  224. def _score_candidates(self, X, y):
  225. self.model.train() # enable dropout
  226. bce = nn.BCEWithLogitsLoss()
  227. acc = torch.zeros_like(self.model.W1) # [hidden1, input_dim]
  229. # multiple gradient samplings with dropout noise
  230. for _ in range(self.n_dropout_samples):
  231. self._zero_candidate_cols()
  232. self.model.zero_grad(set_to_none=True)
  233. logits = self.model(X)
  234. loss = bce(logits, y)
  235. loss.backward()
  236. acc += self.model.W1.grad.clone()
  238. # average outside loop
  239. acc /= float(self.n_dropout_samples)
  241. # Column-wise L2 norms (feature scores)
  242. grad_cols = acc.norm(p=2, dim=0).detach().cpu().numpy() # [input_dim]
  244. # Guard against non-finite values
  245. grad_cols = np.where(np.isfinite(grad_cols), grad_cols, -np.inf)
  247. # Exclude already selected
  248. grad_cols[self.selected_mask_] = -np.inf
  250. # Tie-breaking jitter (seeded, tiny; keeps reproducibility but avoids argmax==0 ties)
  251. rng = np.random.RandomState(self.seed)
  252. eps = rng.normal(loc=0.0, scale=1e-12, size=grad_cols.shape)
  253. tie_safe = grad_cols + eps
  255. j = int(np.argmax(tie_safe))
  256. score = float(grad_cols[j])
  257. return j, score, grad_cols
  259. # -------- public API --------
  260. def fit(self, X, y, X_val=None, y_val=None, k=None, standardize=True):
  261. X = np.asarray(X, dtype=np.float32)
  262. y = np.asarray(y, dtype=np.float32).ravel()
  264. if standardize:
  265. X, mu, sd = standardize_np(X)
  266. self.scaler_ = (mu, sd)
  268. # Small internal validation split (20%) if none provided
  269. if X_val is None or y_val is None:
  270. n = len(X)
  271. m = max(1, int(0.2 * n))
  272. idx = np.arange(n)
  273. rng = np.random.RandomState(self.seed)
  274. rng.shuffle(idx)
  275. val_idx, tr_idx = idx[:m], idx[m:]
  276. Xtr, ytr = X[tr_idx], y[tr_idx]
  277. Xval, yval = X[val_idx], y[val_idx]
  278. else:
  279. Xtr, ytr = X, y
  280. Xval, yval = np.asarray(X_val, dtype=np.float32), np.asarray(y_val, dtype=np.float32)
  281. if standardize and self.scaler_ is not None:
  282. mu, sd = self.scaler_
  283. Xval = (Xval - mu) / sd
  285. Xtr_t, ytr_t = self._to_tensor(Xtr, ytr)
  286. Xval_t, yval_t = self._to_tensor(Xval, yval)
  288. self.ranking_ = []
  289. self.selected_mask_[:] = False
  290. target_k = int(k) if k is not None else self.k_features
  292. for _ in range(min(target_k, self.input_dim)):
  293. # 1) Train subnetwork on current selected set
  294. self._train_subnetwork(Xtr_t, ytr_t, Xval_t, yval_t)
  296. # 2) Score candidates via multi-dropout gradients
  297. j, _, _ = self._score_candidates(Xtr_t, ytr_t)
  299. # 3) Activate feature j
  300. self.selected_mask_[j] = True
  301. self.ranking_.append(j)
  303. # Xavier init for the new column
  304. fan_in = self.model.first.in_features
  305. fan_out = self.model.first.out_features
  306. bound = xavier_bound(fan_in, fan_out)
  307. with torch.no_grad():
  308. self.model.W1[:, j].uniform_(-bound, bound)
  310. self._zero_candidate_cols()
  312. return self
  314. @torch.no_grad()
  315. def predict_proba(self, X):
  316. X = np.asarray(X, dtype=np.float32)
  317. if self.scaler_ is not None:
  318. mu, sd = self.scaler_
  319. X = (X - mu) / sd
  320. Xt, _ = self._to_tensor(X, None)
  321. self.model.eval()
  322. logits = self.model(Xt)
  323. p = torch.sigmoid(logits).cpu().numpy()
  324. return np.vstack([1 - p, p]).T
  326. def selected_features_(self):
  327. return list(self.ranking_)
  330. # -----------------------------
  331. # CLI + main
  332. # -----------------------------
  333. def parse_args():
  334. p = argparse.ArgumentParser(description="Deep Neural Pursuit (DNP) — PyTorch")
  335. p.add_argument('--data', default='./data/data_0.csv', help='CSV: shape (n_samples, n_features)')
  336. p.add_argument('--features', default='./data/features_0.csv', help='CSV: feature names (n_features,)')
  337. p.add_argument('--labels', default='./data/labels.csv', help='CSV: labels (n_samples,)')
  339. p.add_argument('--k', type=int, default=7, help='Number of features to select')
  340. p.add_argument('--hidden', type=str, default='50,30,15', help='Hidden sizes, comma-separated')
  341. p.add_argument('--dropout', type=float, default=0.5, help='Dropout probability')
  342. p.add_argument('--dropout-samples', type=int, default=12, help='Dropout passes for gradient averaging')
  343. p.add_argument('--lr', type=float, default=1e-2, help='Learning rate')
  344. p.add_argument('--epochs', type=int, default=1000, help='Max epochs per greedy iteration')
  345. p.add_argument('--patience', type=int, default=20, help='Early stopping patience per iteration')
  347. p.add_argument('--device', type=str, default="auto", help='cpu/cuda/auto') # safer default
  348. p.add_argument('--seed', type=int, default=42, help='Random seed')
  350. p.add_argument('--standardize', action='store_true', help='Standardize features (z-score)')
  351. p.add_argument('--no-standardize', dest='standardize', action='store_false')
  352. p.set_defaults(standardize=True)
  354. p.add_argument('--stability-runs', type=int, default=0, help='Optional bootstrap runs for stability')
  355. p.add_argument('--output-prefix', type=str, default='selected_genes_dnp', help='Output prefix')
  356. return p.parse_args()
  359. def safe_auc(y_true, y_score):
  360. if not SKLEARN_OK:
  361. return None
  362. try:
  363. return float(roc_auc_score(y_true, y_score))
  364. except Exception:
  365. return None
  368. def jaccard(a, b):
  369. A, B = set(a), set(b)
  370. if not A and not B:
  371. return 1.0
  372. return len(A & B) / max(1, len(A | B)) # correct union
  375. def main():
  376. args = parse_args()
  378. # -----------------------------
  379. # 1. Load data
  380. # -----------------------------
  381. X = pd.read_csv(args.data, header=None).values.astype(np.float32)
  382. genes = pd.read_csv(args.features, header=None)[0].astype(str).tolist()
  383. y = pd.read_csv(args.labels, header=None)[0].values.astype(np.float32)
  385. assert X.shape[1] == len(genes), f"X has {X.shape[1]} cols, features file has {len(genes)} names"
  386. assert X.shape[0] == len(y), f"X has {X.shape[0]} rows, labels file has {len(y)} labels"
  388. # Convert to DataFrame for consistency with other scripts
  389. X_df = pd.DataFrame(X, columns=genes)
  391. hidden = tuple(int(x) for x in args.hidden.split(','))
  393. # -----------------------------
  394. # 2. Fit DNP
  395. # -----------------------------
  396. clf = DNPClassifier(
  397. input_dim=X.shape[1],
  398. hidden_layers=hidden,
  399. k_features=args.k,
  400. dropout_p=args.dropout,
  401. n_dropout_samples=args.dropout_samples,
  402. lr=args.lr,
  403. max_epochs_per_iter=args.epochs,
  404. early_stopping_patience=args.patience,
  405. device=args.device,
  406. seed=args.seed
  407. )
  409. clf.fit(X, y, standardize=args.standardize)
  411. # -----------------------------
  412. # 3. Extract selection
  413. # -----------------------------
  414. sel_idx = clf.selected_features_()
  415. sel_genes = [genes[j] for j in sel_idx]
  417. # -----------------------------
  418. # 4. Build feature ranking (FULL)
  419. # -----------------------------
  420. # You must have something like this in your classifier
  421. # e.g. gradient norms or importance scores
  422. if hasattr(clf, "feature_importances_"):
  423. scores = clf.feature_importances_
  424. elif hasattr(clf, "grad_norms_"):
  425. scores = clf.grad_norms_
  426. else:
  427. # fallback: zero importance except selected
  428. scores = np.zeros(len(genes), dtype=float)
  429. scores[sel_idx] = np.linspace(1.0, 0.5, len(sel_idx))
  431. importance_df = pd.DataFrame({
  432. "feature": genes,
  433. "importance": scores
  434. })
  436. importance_df = importance_df.sort_values(by="importance", ascending=False)
  438. # -----------------------------
  439. # 5. Reduce dataset
  440. # -----------------------------
  441. X_selected = X_df[sel_genes]
  443. print("Selected features:", len(sel_genes))
  444. print("Reduced shape:", X_selected.shape)
  446. # -----------------------------
  447. # 6. Save outputs (MATCH OTHERS)
  448. # -----------------------------
  449. X_selected.to_csv("X_dnp_selected.csv", index=False)
  450. importance_df.to_csv("dnp_feature_ranking.csv", index=False)
  451. pd.Series(sel_genes).to_csv(
  452. "dnp_selected_features.txt",
  453. index=False,
  454. header=False
  455. )
  457. print("\n✅ Files saved:")
  458. print(" - X_dnp_selected.csv")
  459. print(" - dnp_feature_ranking.csv")
  460. print(" - dnp_selected_features.txt")
  462. # -----------------------------
  463. # 7. Optional AUC (same as before)
  464. # -----------------------------
  465. proba_full = clf.predict_proba(X)[:, 1]
  466. auc_full = safe_auc(y, proba_full)
  468. if auc_full is not None:
  469. print(f"AUC (indicative, on full X): {auc_full:.4f}")
  471. # -----------------------------
  472. # 8. Optional stability (unchanged)
  473. # -----------------------------
  474. if args.stability_runs > 0:
  475. rng = np.random.RandomState(args.seed)
  476. selections = []
  478. for r in range(args.stability_runs):
  479. idx = rng.choice(np.arange(len(X)), size=len(X), replace=True)
  480. Xr, yr = X[idx], y[idx]
  482. dnp_r = DNPClassifier(
  483. input_dim=X.shape[1],
  484. hidden_layers=hidden,
  485. k_features=args.k,
  486. dropout_p=args.dropout,
  487. n_dropout_samples=args.dropout_samples,
  488. lr=args.lr,
  489. max_epochs_per_iter=args.epochs,
  490. early_stopping_patience=args.patience,
  491. device=args.device,
  492. seed=args.seed + r + 1
  493. )
  495. dnp_r.fit(Xr, yr, standardize=args.standardize)
  496. selections.append(dnp_r.selected_features_())
  498. jaccs = []
  499. for i in range(len(selections)):
  500. for j in range(i + 1, len(selections)):
  501. jaccs.append(jaccard(selections[i], selections[j]))
  503. stab_mean = float(np.mean(jaccs)) if jaccs else float('nan')
  505. with open('stability_report.txt', 'w', encoding='utf-8') as f:
  506. f.write("DNP Stability (Jaccard over selections)\n")
  507. f.write("=======================================\n")
  508. f.write(f"runs: {len(selections)}\n")
  509. f.write(f"mean_jaccard: {stab_mean:.4f}\n")
  511. print("Saved stability report: stability_report.txt")
  513. if __name__ == '__main__':
  514. main()

dnp_run2.py at commit 1123473, under MIT · at the source

Overview

Authors: Brigitta Varga1, Marlet Martinez-Archundia2, Linette E M Willemsen3, Johan Garssen3,4, Alejandro Lopez-Rincon3
  1. Informatics Institute, University of Amsterdam, Amsterdam, Netherlands
  2. Laboratory for the Design and Development of New Drugs and Biotechnological Innovation, Higher School of Medicine, National Polytechnic Institute (IPN), Mexico, Mexico
  3. Division of Pharmacology, Utrecht Institute for Pharmaceutical Sciences, Faculty of Science, University of Utrecht, Utrecht, Netherlands
  4. Global Centre of Excellence Immunology, Danone Nutricia Research, Utrecht, Netherlands
Institutions: University of Amsterdam (Netherlands); Instituto Politécnico Nacional (Mexico); Utrecht University (Netherlands)
Journal: Frontiers in systems biology, volume 6, article 1873899
Dates: received 6 May 2026; accepted 6 July 2026; published online 3 September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3389/fsysb.2026.1873899 · PMID 42755588 · PMCID PMC13581729 · OpenAlex W7207720905
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: genetics / omics (modality), methods / tools (subfield)
Methods: Connectivity, Statistics, Machine learning, Preprocessing
Keywords: algorithmic integration, feature selection, gene expression, multi-dataset omics, systems microbiology, machine learning
Topic: Bioinformatics and Genomic Networks (Molecular Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Citations: not cited yet (Europe PMC); 75 references in the paper

Abstract

Integrative systems microbiology increasingly relies on algorithmic approaches capable of extracting biologically meaningful patterns from heterogeneous and often high dimensional, low-sample-size (HDLSS) biological datasets. A major obstacle in this setting is the instability of inferred molecular signatures across cohorts, tissues, and measurement platforms. Here, we address this problem by formulating molecular system inference as a multi-dataset integration task and by applying the Matthews Correlation Coefficient–Recursive Ensemble Feature Selection (MCC-REFS) algorithm to jointly analyze five independent transcriptomic datasets spanning peripheral blood mononuclear cells, whole blood, plasma, and post-mortem tissues. We compared MCC-REFS with three commonly used feature-selection strategies, GRACES, SelectKBest, and Deep Neural Pursuit (DNP), in order to evaluate robustness, convergence, and cross-context reproducibility. MCC-REFS consistently converged on a compact seven-gene system (PPP2CB, SOCS3, ARG1, IL6R, ECHS1, FZD2, TRGV3/5) exhibiting higher stability indices and stronger classification performance than alternative methods. Generalization was assessed using an independent multi-layer perceptron classifier across validation cohorts with differing tissue origin and sequencing technologies, demonstrating preservation of discriminative structure. To support interpretation, we integrated functional, pharmacological, and interventional knowledge from DrugBank, DGIdb, and Open Targets, enabling the mapping of inferred gene systems onto pathways, known drug targets, and ongoing clinical investigations. Taken together, this work presents an algorithmic framework for multi-dataset and multi-omics integration in systems microbiology, illustrating how stable and interpretable molecular patterns can be identified from heterogeneous data, with Long COVID serving as a representative case study.

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

Repository

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

steppenwolf0/longCOVIDMCCREFS

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 11234733188788c3cc65dce8ef0c5363760cb855, 27 July 2026
Languages: Python (33)
Size: 161 files, 33 scripts
Software Heritage: not archived
Found in: “Data availability statement”
Holds: README, license file, environment (requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: pandas (31 files), NumPy (29 files), scikit-learn (26 files), Matplotlib (16 files), PyTorch (3 files), PyTorch Geometric (1 file), SciPy (1 file), SHAP (1 file), statsmodels (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
35 files
At the source: github.com/steppenwolf0/longCOVIDMCCREFS

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 33 scripts, each with its path and the digest of its content;
  • 8 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Data availability statement

The datasets analyzed in this study are publicly available from established repositories. Transcriptomic datasets GSE275334 (https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE275334), GSE270045 (https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE270045), GSE226260 (https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE226260), and GSE157103 (https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE157103) were obtained from the NCBI Gene Expression Omnibus (GEO) repository and are accessible at https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc%3cGSE275334 (https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc<GSE275334), https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE270045, https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE226260, and https://www.ncbi.nlm.nih.gov/geo/query/acc.cgi?acc=GSE157103, respectively. Post-mortem tissue RNA-seq data were obtained from the EMBL-EBI Expression Atlas under accession number E-ENAD-46 and are available at https://www.ebi.ac.uk/gxa/experiments/E-ENAD-46. No new data were generated for this study. The code is available in the following repository: https://github.com/steppenwolf0/longCOVIDMCCREFS.

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, pages, dates, 5 authors, 6 keywords, 64 references.

Cite

This paper

Varga, B., Martinez-Archundia, M., Willemsen, L. E. M., Garssen, J., & Lopez-Rincon, A. (2026). A systems microbiology framework for reproducible multi-dataset omics integration with application to long COVID. Frontiers in systems biology, 6, 1873899. https://doi.org/10.3389/fsysb.2026.1873899

BibTeX

@article{varga2026systems,
author = {Varga, Brigitta and Martinez-Archundia, Marlet and Willemsen, Linette E M and Garssen, Johan and Lopez-Rincon, Alejandro},
title = {{A systems microbiology framework for reproducible multi-dataset omics integration with application to long COVID}},
journal = {Frontiers in systems biology},
year = {2026},
month = sep,
volume = {6},
pages = {1873899},
publisher = {Frontiers Media SA},
issn = {2674-0702},
doi = {10.3389/fsysb.2026.1873899},
url = {https://doi.org/10.3389/fsysb.2026.1873899},
pmid = {42755588},
pmcid = {PMC13581729}
}

RIS

TY - JOUR
AU - Varga, Brigitta
AU - Martinez-Archundia, Marlet
AU - Willemsen, Linette E M
AU - Garssen, Johan
AU - Lopez-Rincon, Alejandro
TI - A systems microbiology framework for reproducible multi-dataset omics integration with application to long COVID
T2 - Frontiers in systems biology
J2 - Front Syst Biol
PY - 2026
DA - 2026/09/03
VL - 6
SP - 1873899
SN - 2674-0702
PB - Frontiers Media SA
DO - 10.3389/fsysb.2026.1873899
UR - https://doi.org/10.3389/fsysb.2026.1873899
LA - en
ER -

CSL-JSON

{
"id": "10.3389/fsysb.2026.1873899",
"type": "article-journal",
"title": "A systems microbiology framework for reproducible multi-dataset omics integration with application to long COVID",
"container-title": "Frontiers in systems biology",
"author": [
{
"family": "Varga",
"given": "Brigitta"
},
{
"family": "Martinez-Archundia",
"given": "Marlet"
},
{
"family": "Willemsen",
"given": "Linette E M"
},
{
"family": "Garssen",
"given": "Johan"
},
{
"family": "Lopez-Rincon",
"given": "Alejandro"
}
],
"container-title-short": "Front Syst Biol",
"volume": "6",
"page": "1873899",
"DOI": "10.3389/fsysb.2026.1873899",
"PMID": "42755588",
"PMCID": "PMC13581729",
"ISSN": "2674-0702",
"publisher": "Frontiers Media SA",
"URL": "https://doi.org/10.3389/fsysb.2026.1873899",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
3
]
]
}
}

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.1523/eneuro.0362-25.2026 [code]
Similarities between &lt;i&gt;Ciona&lt;/i&gt; Dorsal Motor Ganglion and Vertebrate Cerebellum: Did a Chordate Ancestor Already Show D/V Subdivision within a Hindbrain Precursor?
Journal: eNeuro
In common: SHAP, PyTorch Geometric, statsmodels, 6 other tools
[2] doi:10.1186/s13059-026-04125-8 [code]
MLMarker: a machine learning framework for tissue inference and biomarker discovery.
Journal: Genome biology
In common: SHAP, statsmodels, PyTorch, 5 other tools, methods / tools, genetics / omics
[3] doi:10.1371/journal.pone.0345854 [code]
Shedding light on neural learning to rank models for anticancer drug prioritization.
Journal: PloS one
In common: SHAP, PyTorch Geometric, PyTorch, 5 other tools
[4] doi:10.1093/bioinformatics/btag253 [code]
PEARL: integrative multi-omics classification and omics feature discovery via deep graph learning.
Journal: Bioinformatics (Oxford, England)
In common: PyTorch Geometric, PyTorch, scikit-learn, 3 other tools, methods / tools, genetics / omics, 1 reference
[5] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: SHAP, statsmodels, PyTorch, 5 other tools, genetics / omics
[6] doi:10.3389/fphys.2026.1830956 [code]
A systematic evaluation of explainable AI methods for high-dimensional transcriptome-based cancer survival prediction.
Journal: Frontiers in physiology
In common: SHAP, statsmodels, PyTorch, 5 other tools, genetics / omics
[7] doi:10.1371/journal.pcbi.1014327 [code]
Supervised deep learning with gene functional annotation for cell classification.
Journal: PLoS computational biology
In common: PyTorch Geometric, statsmodels, PyTorch, 5 other tools, genetics / omics
[8] doi:10.1016/j.isci.2026.116055 [code]
Mapping the transcriptional diversity of calcium signaling in the mouse and human brain.
Journal: iScience
In common: PyTorch Geometric, statsmodels, PyTorch, 5 other tools, genetics / omics
[9] doi:10.1038/s41398-026-03965-z [code]
Disentangling individual heterogeneity reveals robust network and molecular signatures of major depressive disorder with suicidal ideation.
Journal: Translational psychiatry
In common: PyTorch Geometric, statsmodels, PyTorch, 5 other tools, genetics / omics
[10] doi:10.21203/rs.3.rs-9914920/v1 [code]
Prediction of cognitive performance by demographics, sleep, and brain morphometry: machine learning findings from ENIGMA-Sleep Working Group
Journal: Research Square (preprint)
In common: SHAP, statsmodels, scikit-learn, 4 other tools, 1 reference

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.