Conditional Graph Neural Networks

• Conditional Graph Neural Networks (cGNNs) are graph-based models where auxiliary conditions like context or constraints explicitly parameterize predictions.
• They are applied in diverse areas including functional regression, graph-to-graph translation in chemical retrosynthesis, and real-time soft-tissue deformation modeling.
• Key challenges involve constructing effective graph structures, managing sensitivity to neighborhood definitions, and handling permutation variances in the conditional mechanisms.

Searching arXiv for the cited cGNN-related papers to ground the article in the current record. Conditional Graph Neural Network (cGNN) denotes a class of graph-based conditional models in which prediction is explicitly parameterized by auxiliary context, constraints, or input structures rather than by an unconditional mapping alone. In the arXiv literature, the term does not refer to a single standardized architecture. It has been used for a graph neural process over irregularly sampled functions, a conditional autoregressive graph-to-graph model, a logic-constrained retrosynthesis predictor, and a point-cloud-based predictor of soft-tissue deformation and force. Across these formulations, the common principle is conditional inference on graph-structured or graph-derived representations, while the conditioning variable may be a context set, an input graph, a product molecule together with feasible templates, or an external actuation descriptor (Nassar et al., 2018, Wang et al., 2021, Dai et al., 2020, Kojanazarova et al., 7 Jul 2025).

1. Terminological scope and semantic variants

The term cGNN is used heterogeneously across subfields. In functional regression, the relevant object is a conditional distribution over target function values given irregular context samples. In graph-to-graph learning, the condition is an input graph and the output is another graph generated autoregressively. In chemistry, conditioning is imposed through a product graph and logic-gated template feasibility. In deformable-body modeling, conditioning encodes the location and path of an applied deformation.

Formulation	Condition	Predicted object
CGNP	Context set $C$ and target inputs $X_T$	$p(y_T \mid X_T, C)$
Graph2Graph cGNN	Input graph $G_{\text{in}}$	Distribution over $G_{\text{out}}$
CGLN	Product graph $O$ and optional class $c$	Template $T$ and reactant set $\mathcal{R}$
Soft-tissue cGNN	Surface points and tool-tip path	$\delta x$ and $X_T$0

This variety is not merely terminological. It reflects distinct conditional mechanisms: latent summaries and graph pooling in Conditional Graph Neural Processes, node- and edge-level attention in graph-to-graph autoregressive decoding, logic predicates plus conditional energies in retrosynthesis, and readout-stage concatenation of an external condition vector in soft-tissue modeling. A plausible implication is that cGNN is best understood as an umbrella designation for conditional graph-based predictors rather than as a canonical layer type.

2. Conditional Graph Neural Processes and functional prediction

The model introduced as Conditional Graph Neural Process (CGNP) specializes cGNN methodology to functional processes on a metric space $X_T$1 with distance $X_T$2. The observed data are an irregular context set $X_T$3, where $X_T$4, and the task is to predict values at a target set $X_T$5. The central object is the conditional distribution $X_T$6, with context observations treated as nodes in a graph whose edges encode proximity or similarity under the metric on the input domain (Nassar et al., 2018).

In the deterministic variant, a GNN encoder computes node embeddings from raw features $X_T$7 and aggregates them into a global context representation $X_T$8. A decoder then predicts a per-target Gaussian likelihood,

$X_T$9

and training minimizes Gaussian negative log-likelihood,

$p(y_T \mid X_T, C)$0

The same architecture also admits a latent extension with a global latent $p(y_T \mid X_T, C)$1 and an ELBO-style objective involving $p(y_T \mid X_T, C)$2, $p(y_T \mid X_T, C)$3, and a KL term weighted by $p(y_T \mid X_T, C)$4, although the reported experiments use the deterministic case.

Graph construction is central. The context graph may be built with $p(y_T \mid X_T, C)$5-NN, $p(y_T \mid X_T, C)$6-ball, or kernel-weighted edges; the reported implementation uses a radius graph with neighborhood radius $p(y_T \mid X_T, C)$7. Message passing follows a permutation-invariant aggregation scheme, and the paper also gives a bipartite graph convolution form

$p(y_T \mid X_T, C)$8

After $p(y_T \mid X_T, C)$9 graph-convolution layers, graph-level pooling yields

$G_{\text{in}}$0

Decoding can be done by concatenating $G_{\text{in}}$1 and passing it through an MLP, or by graph-based bipartite decoding from context or latent nodes to targets.

The empirical study uses 1-D regression targets generated from a Gaussian process with an exponentiated quadratic kernel of length $G_{\text{in}}$2, with irregular context and target points sampled from $G_{\text{in}}$3. The baseline CNP employs a 3-layer encoder and 2-layer decoder MLP, while CGNP replaces them with bipartite graph convolution networks. All models use latent feature dimension $G_{\text{in}}$4, Adam with learning rate $G_{\text{in}}$5, and pre-activation batch normalization. Reported test performance is: CNP, $G_{\text{in}}$6 and $G_{\text{in}}$7; CGNP with $G_{\text{in}}$8, $G_{\text{in}}$9 and $G_{\text{out}}$0; CGNP with $G_{\text{out}}$1, $G_{\text{out}}$2 and $G_{\text{out}}$3. The contrast between $G_{\text{out}}$4 and $G_{\text{out}}$5 isolates the effect of local graph neighborhoods: using local metric structure markedly improves NLL and slightly improves MSE, whereas disconnecting the graph reverts behavior toward the set-based CNP encoder.

The paper explicitly frames this as an argument for exploiting local structures of metric spaces. GNN message passing can capture local continuity, smoothness, and non-stationary behavior more directly than global set pooling. At the same time, the formulation inherits limitations tied to graph construction and geometry: sensitivity to the neighborhood radius $G_{\text{out}}$6, reliance on a meaningful metric $G_{\text{out}}$7, vulnerability under sparse or uneven contexts, and over-smoothing in deeper or denser GNNs.

3. Conditional graph-to-graph autoregressive models

A different usage of cGNN appears in graph-to-graph learning, where the model defines a conditional distribution over output graphs given an input graph,

$G_{\text{out}}$8

and decodes the target graph autoregressively as a sequence of lower-triangular adjacency vectors (Wang et al., 2021). Given a fixed node ordering $G_{\text{out}}$9, an undirected graph is represented row-wise by

$O$0

with an analogous output sequence $O$1 for the decoder. The joint output distribution factorizes across nodes and then across edges within each node:

$O$2

The encoder is a two-level stacked RNN rather than a classical MPNN. An edge-level GRU, encEdgeRNN, processes each adjacency row, and a bidirectional node-level GRU, encNodeRNN, propagates across rows. Attention then produces node-level contexts

$O$3

with edge-level contexts $O$4 defined analogously over encoder edge states. The decoder mirrors this hierarchy with decNodeRNN and decEdgeRNN, and an MLP with sigmoid outputs Bernoulli parameters $O$5 for edge existence. Training uses negative log-likelihood instantiated as Focal loss with $O$6 to handle sparsity:

$O$7

The model is evaluated on maximum clique prediction over DBLP_v1, IMDB-MULTI, and deezer_ego_nets, using 60/20/20 train/validation/test splits, Adam with learning rates in $O$8, and batch sizes in $O$9. Reported results for the full conditional autoregressive Graph2Graph model are: DBLP_v1, Accuracy $c$0 and Edge IoU $c$1; IMDB-MULTI, Accuracy $c$2 and Edge IoU $c$3; deezer_ego_nets, Accuracy $c$4 and Edge IoU $c$5. Ablations show lower performance without node-level attention or without edge-level attention, indicating that both context channels contribute materially to structured prediction quality.

The same encoder–decoder is also used as a graph autoencoder, where single-directional RNNs compress graphs into a 128-dimensional latent embedding $c$6, and as an unsupervised pretraining mechanism for graph classification. The reported conclusion is that pretrained cGNN latent embeddings consistently outperform GIN in the small-label regime and approach similar performance with full labels. This formulation thereby places cGNN in the lineage of conditional seq2seq-style transducers, but with graph-valued inputs and outputs and explicit node- and edge-level attention over graph-derived sequence states.

Its limitations are correspondingly specific. The approach depends on node ordering and uses depth-first traversal as a canonicalization rather than achieving strict permutation invariance. Decoding is sequential and scales as $c$7 over lower-triangular adjacency entries, memory increases with stored attention states, and zero-padding to a fixed maximum graph size is expensive for variable-sized graphs.

4. Logic-gated conditional graph models in retrosynthesis

In retrosynthesis, the Conditional Graph Logic Network (CGLN) casts single-step prediction as conditional structured inference over a product molecule, a reaction template, and a reactant set (Dai et al., 2020). The product is a labeled graph $c$8, denoted $c$9 in the paper. A template

$T$0

is a subgraph rewriting rule extracted from atom-mapped reactions. Applicability is enforced by logic predicates:

$T$1

and

$T$2

for some permutation $T$3 of reactants.

Conditional distributions are then defined by energy-based scores,

$T$4

so that the joint satisfies

$T$5

To make template selection tractable, the template score is decomposed as

$T$6

which induces a hierarchy from reaction center to template to reactant set.

The graph neural parameterization uses structure2vec-style message passing,

$T$7

with graph embeddings formed by mean pooling over node states. These embeddings parameterize template and reactant compatibility functions such as

$T$8

Because $T$9 decomposes over atoms in $\mathcal{R}$0, the model provides atom-level attributions for predicted reaction centers.

On USPTO-50k, with the standard 80/10/10 split and Top-$\mathcal{R}$1 exact match evaluation, GLN reaches Top-1 accuracy $\mathcal{R}$2 without reaction class priors, versus $\mathcal{R}$3 for neuralsym, an improvement of $\mathcal{R}$4. With reaction class provided, GLN reaches $\mathcal{R}$5 Top-1 versus $\mathcal{R}$6 for neuralsym. Top-50 approaches the reported template coverage upper bound of $\mathcal{R}$7, and on USPTO-full the model reports Top-1 $\mathcal{R}$8 compared with $\mathcal{R}$9 for retrosim and $\delta x$0 for neuralsym. Efficiency is obtained by hierarchical inference and importance sampling over restricted feasible supports, with average support sizes on USPTO-50k of $\delta x$1 and $\delta x$2.

This instantiation broadens the meaning of cGNN beyond conventional encoder–decoder architectures. Conditioning here is expressed through normalized conditional energies under hard logical constraints, and graph neural networks serve as the parameterization of those energies. The model’s limits are likewise domain specific: reactions outside the template vocabulary cannot be recovered, template specificity can fail in either direction, chemically ambiguous alternatives remain difficult even with correct center detection, and subgraph matching remains a preprocessing bottleneck.

5. Conditional point-cloud GNNs for deformable-body prediction

A recent use of cGNN concerns soft-tissue simulation from sparse surface measurements and applied tool-path information (Kojanazarova et al., 7 Jul 2025). The input is a point cloud of $\delta x$3 tracked surface points $\delta x$4 together with the start and end positions of the indentation tip, encoded as the condition vector $\delta x$5. The outputs are the per-point displacement field $\delta x$6 and the change in force magnitude $\delta x$7. The paper’s motivation is explicit: the same tissue geometry can deform differently depending on where force is applied and along which path the tool moves, so the model must encode both “where” and “how”.

The graph is a directed $\delta x$8-NN graph with $\delta x$9 neighbors per node and self-loops. The topology is recomputed dynamically at each DynamicEdgeConv layer, so neighborhoods depend on current features. With initial node features $X_T$00, message passing uses

$X_T$01

with mean aggregation. After three EdgeConv layers, the concatenated node embedding is

$X_T$02

Conditioning is injected at readout rather than within message passing. The node-wise displacement head is

$X_T$03

and the graph-level force head is

$X_T$04

Training uses a displacement loss

$X_T$05

a force loss

$X_T$06

and total objective

$X_T$07

with $X_T$08. Optimization uses Adam, learning rate $X_T$09, batch size $X_T$10, and $X_T$11 epochs. To address limited real data, the model is pretrained on a mass-spring model (MSM) dataset of 16,500 static simulation examples and then fine-tuned on experimentally measured deformations from a silicone phantom with 25 passive reflective markers and ATI Nano17 force sensing.

The reported experimental results are central. Without transfer learning, cGNN/Exp gives mean displacement error $X_T$12 mm, maximum displacement error $X_T$13 mm, force MAE $X_T$14 N, and force MSE $X_T$15 N$X_T$16. With MSM pretraining followed by fine-tuning, cGNN/MSM yields mean displacement error $X_T$17 mm, maximum error $X_T$18 mm, force MAE $X_T$19 N, and force MSE $X_T$20 N$X_T$21. With augmented MSM pretraining, the best reported result is mean displacement error $X_T$22 mm and force absolute error $X_T$23 N, summarized in the abstract as accurate prediction for deformations up to $X_T$24 mm and forces up to $X_T$25 N. The noCond ablation, which removes conditioning, degrades severely: on MSM data, mean displacement error rises from $X_T$26 mm to $X_T$27 mm, while force MAE rises from $X_T$28 N to $X_T$29 N.

Runtime is also reported explicitly: MSM forward simulation on 1024 points requires $X_T$30 s per static example, whereas cGNN inference takes $X_T$31 s for 1024-point MSM-sized input and $X_T$32 s for the experimental input of roughly 26 points, approximately $X_T$33 Hz. This makes the method suitable for real-time haptic feedback loops under the reported setup. The stated limitations include simplified geometry, absence of volumetric effects and viscoelasticity, dynamic-neighborhood cost at high point counts, residual simulation-to-real domain gap, and sensitivity to point density and graph construction.

6. Cross-cutting design principles, misconceptions, and limitations

Several design axes recur across these formulations. First, the condition may be encoded globally or structurally. CGNP pools context-node embeddings into a global latent summary $X_T$34 or latent variable $X_T$35. The graph-to-graph model derives node-level and edge-level contexts through attention over encoder states. CGLN uses graph embeddings to parameterize conditional energies while hard logic predicates delimit feasible outputs. The soft-tissue model concatenates an external condition vector to node and graph embeddings at the output heads rather than modifying messages directly.

Second, graph structure may be intrinsic, constructed, or imposed by symbolic rules. In CGNP, graphs are built over irregular samples using radius or $X_T$36-NN neighborhoods in a metric space. In the soft-tissue model, dynamic $X_T$37-NN graphs define local geometric coupling among surface markers. In the graph-to-graph model, graph structure is converted into an ordered adjacency sequence, so the effective propagation path is sequence-based. In CGLN, the relevant structure combines molecular graphs with subgraph-isomorphism constraints induced by reaction templates.

Third, invariance properties differ substantially. CGNP uses permutation-invariant neighborhood aggregation and graph-level pooling. The soft-tissue cGNN uses symmetric mean aggregation in DynamicEdgeConv. By contrast, the graph-to-graph autoregressive cGNN depends on node ordering and only mitigates permutation variance through depth-first canonicalization. CGLN is not primarily framed in terms of permutation invariance; instead, it relies on molecular graph embeddings and deterministic subgraph matching.

A frequent misconception is that cGNN names a single architecture analogous to GCN, GAT, or GraphSAGE. The cited literature does not support that interpretation. One paper uses the term for a conditional graph neural process over function spaces, another for a conditional autoregressive graph transducer, another for a conditional graph logic network, and another for a dynamic-edge-convolution model on surface point clouds. The unifying attribute is conditional graph-based prediction, not a fixed computational template.

Common failure modes also vary by formulation but share a dependence on how conditioning interfaces with structure. CGNP is sensitive to graph connectivity, the metric on $X_T$38, sample density, and over-smoothing. The graph-to-graph model faces ordering dependence, sequential $X_T$39 decoding cost, and zero-padding inefficiency. CGLN is bounded by template coverage, template specificity, and preprocessing through subgraph matching. The soft-tissue cGNN depends on point density, dynamic graph construction, and simulation-to-real transfer quality. Taken together, these results suggest that the principal technical challenge in cGNN design is not merely message passing; it is the alignment between the condition variable, the graph representation, and the output factorization.