SigXTalk: Dissecting Cell-Cell Communication Crosstalk with Hypergraph Learning

· 10 min read · Paper Feed

SigXTalk: Dissecting Cell-Cell Communication Crosstalk with Hypergraph Learning

Paper: Dissecting crosstalk induced by cell-cell communication using single-cell transcriptomic data
Authors: Jiawen Hou, Wei Zhao, Qing Nie
Published: Nature Communications 16, 2025 | DOI: 10.1038/s41467-025-61149-7
Code: github.com/LithiumHou/SigXTalk

The Problem Nobody Was Solving

Cells talk. They send ligands, receive them through receptors, and trigger cascades of intracellular regulation that ultimately change which genes get expressed. This process — cell-cell communication (CCC) — has been a hot area of single-cell genomics, with tools like CellChat, NicheNet, and CellPhoneDB enabling researchers to reconstruct who is signaling to whom and through which ligand-receptor pair.

But there's a largely ignored wrinkle: the downstream pathways triggered by different ligand-receptor pairs don't operate in isolation. They talk to each other. They share transcription factors. They share target genes. One CCC signal can inadvertently activate a pathway meant for a different receptor — or two unrelated signals can converge on the same target gene through completely different routes.

This is pathway crosstalk, and it has profound implications for how we interpret CCC analysis. If TGFBR1 is activated and it also shares a downstream kinase with the Hippo pathway, how do we know which "pathway" is actually driving expression of a given target gene? How "selective" is a signaling axis, really?

These are the central questions addressed by SigXTalk, a new computational method from Hou, Zhao, and Nie at UC Irvine, published in Nature Communications in 2025.

Two New Concepts: Fidelity and Specificity

Before getting into the method, it's worth sitting with the two conceptual innovations in this paper.

Pathway fidelity asks: does a target gene get activated only by the CCC signal that's supposed to regulate it, or can other signals "leak in" through shared regulators? High fidelity means the pathway is selective — the target responds specifically to its intended signal.

Pathway specificity asks: does a CCC signal activate only the targets it's supposed to, or does it scatter signal across many targets via shared downstream components? High specificity means the signal is focused.

Figure 1c (paper): The "fidelity problem" — a target gene regulated by multiple upstream signals — and the "specificity problem" — a signal activating multiple targets through shared intermediates.

These two dimensions together give a richer, more realistic picture of CCC than simple pairwise ligand→receptor→target analyses can provide.

How SigXTalk Works

SigXTalk is a four-stage pipeline that takes scRNA-seq data and cell type annotations as input and outputs a quantified landscape of crosstalk between signaling pathways.

Stage 1 — CCC Inference with CellChat

SigXTalk first runs CellChat on the input data to identify which ligand-receptor (LR) pairs are active between cell types. The activated receptors in the receiver cell type become the "signal inputs" for the downstream analysis.

Figure 1d (paper): Workflow overview — CCC analysis identifies activated receptors as signals, which feed into the hypergraph learning module.

Stage 2 — Hypergraph Neural Network for Pathway Activation

This is the novel core of the method. Rather than restricting analysis to pairwise gene-gene edges (as in standard GRN inference), SigXTalk builds a hypergraph — a graph where a single "hyperedge" can connect multiple nodes simultaneously, naturally encoding higher-order regulatory interactions.

A prior skeleton hypergraph is assembled from curated gene-gene interaction databases (the same prior knowledge used by NicheNet), connecting:

  • Receptors (R) → Shared Signaling Components (SSC, typically TFs) → Target Genes (TG)

This skeleton is fed into a hypergraph neural network (HGNN) together with the single-cell expression matrix as node features. The HGNN's convolution layers aggregate neighborhood information from the hyperedge structure, producing low-dimensional gene embeddings. The output is a pathway activation probability — the likelihood that each R→SSC→TG path is genuinely active in the data.

Stage 3 — Pathway Regulatory Strength (PRS) via Random Forest

After filtering low-probability pathways, SigXTalk quantifies the regulatory strength of each surviving pathway using Random Forest regression. For each SSC→TG pair, it fits the SSC's activation score using the expression levels of all upstream signals, measuring the proportion of explained variance attributable to each signaling pathway.

Figure 1e (paper): Crosstalk quantification — PRS is estimated via Random Forest regression, then used to derive fidelity and specificity within each crosstalk module.

Stage 4 — Crosstalk Module Analysis

Pathways sharing the same signals, SSCs, or targets are grouped into crosstalk modules (Xmods). There are three flavors:

  • XMs: share upstream CCC signals
  • XMC: share intermediate signaling components (SSCs/TFs)
  • XMT: share downstream target genes

Within each module, fidelity and specificity are computed as relative PRS proportions — essentially, what fraction of a target gene's regulation comes from this pathway versus all others in the module.

What It Can Find That Others Can't

The paper benchmarks SigXTalk on SERGIO-simulated data with known ground truth regulatory networks, outperforming 12 existing GRN inference methods (GENELink, PIDC, GRNVBEM, GRNBoost2, PPCOR, SCODE, SINCERTIES, LEAP, GRISLI, and others) in recovering activated regulatory pathways.

Applied to real data — including PBMC datasets, mouse embryo development, and cancer microenvironments — SigXTalk reveals:

  • Cell-type-specific crosstalk: The same target gene may be regulated by completely different signaling axes depending on the cell type.
  • Temporal evolution of crosstalk: When applied to multi-timepoint data, SigXTalk tracks how pathway crosstalk changes as cell states evolve.
  • Species-conserved crosstalk: Crosstalk patterns identified in human data are partly conserved in mouse, supporting biological significance.
  • Cross-pathway signal leakage: In some contexts, a CCC signal "hijacks" pathways not originally associated with its receptor, dramatically changing the interpretation of which signals drive which transcriptional outcomes.

Getting Started with SigXTalk

SigXTalk is an R+Python hybrid package. The R side handles preprocessing, CCC, and visualization; the Python side runs the hypergraph neural network. Here's how to get up and running:

Installation

R package (from GitHub):

# Install Bioconductor dependencies first
if (!require("BiocManager", quietly = TRUE))
    install.packages("BiocManager")
BiocManager::install(c("Biobase", "BiocNeighbors", "ComplexHeatmap", "BiocGenerics"))

# Install SigXTalk R package
devtools::install_github("LithiumHou/SigXTalk", dependencies = TRUE, upgrade = "always")

Python module (in a dedicated conda environment):

conda create -n SigXTalk_py python=3.8
conda activate SigXTalk_py

# GPU-accelerated (Linux/Windows with CUDA)
pip install torch==1.13.1+cu117 --extra-index-url https://download.pytorch.org/whl/cu117

# CPU only (or macOS)
pip install torch==1.13.1

# Install SigXTalk Python module
pip install git+https://github.com/LithiumHou/SigXTalk.git#subdirectory=pythoncodes

Load Data and Run CCC

library(SigXTalkR)
library(Seurat)
library(dplyr)
library(CellChat)

# Load your Seurat object (normalized, scaled, annotated)
SeuratObj <- readRDS("./SigXTalk_demo_data.rds")
cell_anno <- data.frame(
    cell    = names(Idents(SeuratObj)),
    cluster = Idents(SeuratObj) %>% as.character()
)

# Load and filter prior gene-gene interaction databases
data("RTF_human")   # Receptor → TF interactions
data("TFT_human")   # TF → Target gene interactions
RecTFDB <- RTF_human %>% distinct(from, to, .keep_all = TRUE) %>%
           Filter_DB(rownames(SeuratObj@assays$RNA$data))
TFTGDB  <- TFT_human %>% distinct(from, to, .keep_all = TRUE) %>%
           Filter_DB(rownames(SeuratObj@assays$RNA$data))

# Infer cell-cell communication with CellChat
LR_original <- Infer_CCI(SeuratObj, cell_anno, use_spatial = FALSE, db_use = "human")

Prepare Inputs and Run the HGNN

# Choose a receiver cell type and identify target genes
target_type <- "CD14_Mono"
TG_used <- FindMarkers(SeuratObj, target_type, min.pct = 0.25,
                       only.pos = TRUE, logfc.threshold = 0.25)
TG_used <- filter(TG_used, p_val_adj < 1e-3) %>% rownames()

# Prepare input files for the Python HGNN module
Prepare_Input(SeuratObj, target_type, TGs = TG_used,
              CCC_results = LR_original, RecTFDB, TFTGDB,
              data_dir = "./inputs", assay = "RNA",
              datatype = "scale.data",
              exp_threshold = 0.05, CCC_threshold = 0.05)

# Run the hypergraph neural network (Python)
conda_env  <- "SigXTalk_py"
python_script <- "./main.py"
args <- c("--project", "PBMC", "--target_type", target_type)
Run_py_script(python_script, conda_env, args)

Calculate PRS and Visualize Crosstalk

# Load pathway predictions and keep high-confidence activations
RTFTG_results <- read.csv("./outputs/PBMC/pathways_CD14_Mono.csv", header = TRUE)
RTFTG_results <- RTFTG_results[RTFTG_results$pred_label > 0.75, 1:3]

# Compute Pathway Regulatory Strength (PRS)
Exp_clu          <- Get_Exp_Clu(SeuratObj, clusterID = target_type,
                                assay = "RNA", datatype = "data", cutoff = 0.1)
ress             <- PRS_calc(Exp_clu, RTFTG_results, cutoff = 0.1)
results_filtered <- Filter_results(ress, PRS_threshold = 0.01)

# Visualize crosstalk summary
library(ggplot2); library(patchwork); library(ggalluvial)

ps <- PlotXT_Counts(results_filtered, top_percent = 1)
ps$outer   # outer ring: signal-level crosstalk counts
ps$inner   # inner ring: target-level crosstalk counts

# Heatmap of top target genes with most crosstalk pathways
Counts_pathway <- Count_Crosstalk(results_filtered, KeyGenes = NULL,
                                  data_type = "Target", verbose = FALSE)
TG_top <- sort(Counts_pathway, decreasing = TRUE) %>% names() %>% head(15)
CC_pair_results <- Aggregate_Causality(results_filtered, data_type = "Target")
PlotXT_RecTGHeatmap(CC_pair_results, Exp_clu, KeyTG = TG_top, topk = 100)

# Alluvial plot for a specific target gene — see the flow of regulation
PlotXT_Alluvial(results_filtered, TG_top[1:3], min_weight = 0.8)

# Fidelity vs. specificity scatter for a target gene
PlotXT_FidSpe(results_filtered, TG_top[1], threshold = 0.01)

Why This Matters

Most single-cell CCC analysis stops at the receptor: we know that ligand X is signaling to receptor Y in cell type Z, and maybe we predict that target gene T is downstream. But this is a linear view of a decidedly non-linear biological system.

Crosstalk is not a bug — it's a feature. Cells use shared signaling components to integrate inputs from multiple sources, make decisions under uncertainty, and maintain robustness. SigXTalk is the first method to systematically quantify this integration from scRNA-seq data, and to ask: when a target gene changes expression, how much of that change is really attributable to the CCC pathway we think is responsible?

For anyone studying developmental biology, cancer immunology, or tissue homeostasis — anywhere cells are in conversation with each other — SigXTalk adds a necessary layer of mechanistic nuance.

Key Takeaways

  • CCC analysis has been missing crosstalk — pathways share signals, TFs, and targets, and this distorts naive interpretations
  • SigXTalk introduces fidelity and specificity as quantitative measures of pathway selectivity in CCC
  • Hypergraph neural networks capture higher-order regulatory relationships that pairwise GRN methods miss
  • Random Forest PRS provides an interpretable, regression-based measure of regulatory strength per pathway
  • Open source, R+Python, with a step-by-step tutorial and PBMC demo data

Paper: Nature Communications 2025
GitHub: LithiumHou/SigXTalk

Originally posted on WeChat Official Account: bioinfo_studyroom

Single Cell CCC Deep Learning GRN Paper Feed