Cell-Leaf Graph (CLG) for Single-Cell Analysis

• Cell-Leaf Graph (CLG) is a bipartite graph method that leverages shared leaf assignments from ensemble regression trees to capture gene regulatory decisions.
• It fuses forest-derived cell–leaf relations with traditional KNN graphs to enrich single-cell RNA-seq embeddings for visualization, clustering, and trajectory inference.
• The method enhances rare cell type detection by combining regulatory-pattern similarity with expression similarity, optimized via grid search on fusion weights.

The Cell-Leaf Graph (CLG) is a bipartite graph construction for single-cell RNA-seq embedding in which cells are linked not only through expression similarity but through shared leaf assignments in ensembles of regression trees trained gene-by-gene. In the formulation introduced by Torabi Goudarzi and Pouyan, the CLG is designed to capture, at the level of individual cells, similarity in “regulatory decisions” obtained when each gene is predicted from all remaining genes via random-forest regression models; these cell–leaf relations are then fused with a standard cell–cell K-nearest-neighbor graph to form an Enriched Cell-Leaf Graph (ECLG), which is subsequently embedded for downstream analysis such as visualization, clustering, and trajectory inference (Goudarzi et al., 1 Sep 2025).

1. Conceptual basis

The CLG was introduced against the background that, in almost all single-cell embedding methods, including PCA, t-SNE, UMAP, deep autoencoders, etc., the relationships used to pull cells together in low-dimensional space are direct gene-expression similarities. The motivating claim is that biology is also regulated by gene–gene interactions (epistasis)—including co-expression, repression, feed-forward loops—and that these interactions carry information orthogonal to raw expression values (Goudarzi et al., 1 Sep 2025).

In this framework, the CLG is a data-driven representation of those interactions. For each target gene, a random-forest regression model is trained to predict that gene from the remaining genes. Each cell traverses every tree and lands in a leaf. Two cells that repeatedly land in the same leaves across many such trees are treated as sharing similar underlying gene–gene interaction patterns. The resulting object is not a direct gene–gene interaction network; rather, it is a cell–leaf incidence structure induced by forests trained on the expression matrix. This suggests that the CLG encodes regulatory-pattern similarity indirectly, through shared partitioning decisions of the ensemble.

2. Mathematical definition

Let:

• $n$ be the number of cells,
• $p$ be the number of genes after variable-gene filtering,
• $X \in \mathbb{R}^{n \times p}$ be the preprocessed expression matrix, specified as log-normalized, HVG-filtered,
• and for each $i = 1,\dots,p$, let $RF_i$ be a random-forest regression model trained to predict gene $i$ from the other $p-1$ genes.

The node set is divided into two parts. First, the cell set is

$U = \{c_1,\dots,c_n\}.$

Second, for each forest $RF_i$ and each of its $T$ trees, let

$p$0

denote the leaf set of tree $p$1 in forest $p$2. The full leaf-node set is then

$p$3

The CLG edge set is bipartite:

$p$4

In practice, every cell passes down every tree and ends up in exactly one leaf per tree, so across $p$5 trees each cell is incident to exactly $p$6 leaf nodes. The adjacency matrix is block-structured. If the first $p$7 indices correspond to cells and the remaining indices to leaves, then

$p$8

where

$p$9

The construction assigns uniform weight $X \in \mathbb{R}^{n \times p}$0 to each cell–leaf edge. The summary also allows optional pruning of very small leaves by discarding any $X \in \mathbb{R}^{n \times p}$1 whose support satisfies

$X \in \mathbb{R}^{n \times p}$2

with the stated rationale of removing spurious splits (Goudarzi et al., 1 Sep 2025).

A direct implication of the block form is that the CLG itself contains no cell–cell edges and no leaf–leaf edges. Those relations are introduced only at the fusion stage.

3. Algorithmic construction from scRNA-seq data

The CLG is constructed from the preprocessed matrix $X \in \mathbb{R}^{n \times p}$3 by training one forest per target gene. The input parameters given in the summary are the number of trees $X \in \mathbb{R}^{n \times p}$4 and the minimum leaf size $X \in \mathbb{R}^{n \times p}$5. The output is the sparse binary adjacency $X \in \mathbb{R}^{n \times p}$6 (Goudarzi et al., 1 Sep 2025).

The procedure is presented in code-style form:

$p-1$4

After this loop, V_list holds all leaf nodes in $X \in \mathbb{R}^{n \times p}$7, and $X \in \mathbb{R}^{n \times p}$8 holds the bipartite cell–leaf adjacency. If desired, columns corresponding to leaves with low support can be pruned by removing those satisfying $X \in \mathbb{R}^{n \times p}$9.

Operationally, this means the CLG is assembled from the leaf memberships induced by all forests rather than from an explicit estimate of a gene regulatory network. The summary explicitly associates this forest-based step with GENIE3, and the intuition offered is that each tree split can be interpreted as an implicit small gene–gene interaction. This suggests that the CLG captures a distributed, ensemble-derived surrogate for regulatory structure rather than a single sparse causal graph.

4. Fusion with the K-nearest-neighbor graph

The CLG is not used in isolation. It is combined with a standard cell–cell K-Nearest Neighbor Graph (KNNG) to form the Enriched Cell-Leaf Graph (ECLG). The KNN graph is built by first projecting $i = 1,\dots,p$0 to 50 PCs by PCA, then identifying, for each cell, its $i = 1,\dots,p$1 nearest neighbors using Euclidean distance in PC space. The weighted adjacency is defined by

$i = 1,\dots,p$2

with $i = 1,\dots,p$3 chosen by Nearest-Neighbor Error (NNE) minimization; the summary gives $i = 1,\dots,p$4 as an example (Goudarzi et al., 1 Sep 2025).

The fused adjacency on the joint node set $i = 1,\dots,p$5 is

$i = 1,\dots,p$6

or, equivalently, in block form,

$i = 1,\dots,p$7

Here, $i = 1,\dots,p$8 are hyper-parameters used to re-weight the two modalities:

• cell–cell edges from the KNNG, with weight $i = 1,\dots,p$9,
• cell–leaf edges from the CLG, with weight $RF_i$0.

The summary states that, in practice, $RF_i$1 and $RF_i$2 are chosen by a small grid search over $RF_i$3 to minimize NNE on a held-out set. The explicit purpose of this fusion is to encode both direct expression similarity and regulatory-pattern similarity within a single graph.

5. Embedding stage and model choice

A notable technical point is that, although the abstract refers to “graph neural networks,” the main text applies the LINE algorithm to the ECLG rather than a GNN. In the reported implementation, LINE is used to learn $RF_i$4-dimensional vectors $RF_i$5 for every cell node $RF_i$6, preserving both first-order proximity and second-order proximity (Goudarzi et al., 1 Sep 2025, Tang et al., 2015).

The two objectives are written as

$RF_i$7

and

$RF_i$8

The final embedding is $RF_i$9, with $i$0 by default, and these vectors are then used for clustering, visualization, and related tasks.

The summary also states that, if one wished instead to use a GNN, one could replace LINE with e.g. a 2-layer GraphSAGE or GCN, using the forward pass

$i$1

together with a cross-entropy or triplet-loss objective on cell-type labels or NNE. In the source description, however, this remains a hypothetical replacement rather than the main implementation.

This distinction is important because CLG and ECLG are graph constructions, whereas the embedding model is a separate choice. A common misconception is to conflate the graph representation with the downstream encoder; the summary instead separates them explicitly.

6. Implementation details, reported uses, and interpretive significance

The technical summary specifies the following implementation details and hyper-parameters for the reported pipeline (Goudarzi et al., 1 Sep 2025):

Component	Stated setting
Highly variable genes $i$2	$i$3
Random forests	$i$4 trees per forest, min_samples_leaf=10
KNNG	$i$5 nearest neighbors, $i$6
CLG pruning	discard leaves with $i$7 cells
Fusion weights	$i$8 chosen by grid search
Embedding	LINE with $i$9
Visualization	t-SNE/UMAP

The workflow is also summarized textually in four phases: preprocess $p-1$0 and select top genes; construct the CLG by training $p-1$1 for each gene and connecting each cell to each leaf it falls in; construct the KNNG in PC space with RBF weights; and merge the graphs into the ECLG and run LINE to obtain $p-1$2.

The paper reports that this integrated graph improves the detection of rare cell populations and improves downstream analyses such as visualization, clustering, and trajectory inference relative to expression-only methods. A more specific restatement in the technical summary is that the fused graph yields cell representations that improve rare cell type detection, clustering quality, and visualization fidelity relative to expression-only approaches.

From the formalism, one can distinguish several interpretive points. First, the CLG is a bipartite incidence graph over cells and leaves, not a gene graph. Second, the ECLG is a multimodal fusion in which the KNN component contributes direct expression geometry and the CLG component contributes forest-derived regulatory-pattern similarity. Third, because each cell is incident to exactly $p-1$3 leaves before pruning, the representation aggregates a large number of ensemble decisions. This suggests that the method treats repeated co-occurrence in leaf nodes as a stable signal of shared cellular state.

A central caveat concerns the mismatch between the abstract and the main text: the abstract presents the ECLG as input for a graph neural network, whereas the detailed summary states that the main text in fact uses LINE. This is not merely terminological. It separates the contribution into two parts: a graph construction mechanism, namely CLG and ECLG, and an embedding back end, which in the reported implementation is a network embedding algorithm rather than a message-passing neural architecture.